Lecture 02

Software Process
Software Engineering
COSC-1104

Ms. Humaira Anwer

[email protected]

Lecture 02 Software Process 1

 Software Process
• Fundamental Assumption:

• Good processes lead to good software

• Good processes reduce risk
• Good processes enhance visibility
• Good processes enable teamwork

Lecture 02 Software Process 2

 Variety of Software
Processes
• Software products are very varied...
• Therefore, there is no standard process for all
software engineering projects
• BUT successful software development projects all
need to address similar issues.
• This creates a number of process steps that should
be part of all software projects.

Lecture 02 Software Process 3

 Basic Steps in all Software
Development
• Feasibility and planning
• Requirements These steps may be repeated
many times during the
• Design
development cycle
• Implementation (coding)
• Testing
• Deployment/Release/Install
• Operation and maintenance

It is essential to distinguish among these steps and to be clear which you are
doing at any given moment.
Note
• Considerations of testing, security and performance are part of many of
these steps.
Lecture 02 Software Process 4
 Feasibility
A feasibility study precedes the decision to begin a
project.

• What is the scope of the proposed project?

• Is the project technically feasible?
• What are the projected benefits?
• What are the costs, timetable?
• Are the resources available?
• What are the risks and how can they be managed?

A feasibility study leads to a decision: go or no-go.

Lecture 02 Software Process 5
 Requirements
• Requirements define the function of the system from the client's viewpoint.
• The requirements establish the system's functionality, constraints, and goals
by consultation with the client, customers, and users.
• They must be developed in a manner that is understandable by both the
client and the development staff
• This step is sometimes divided into:
• Requirements analysis
• Requirements definition
• Requirements specification

• The requirements may be developed in a self-contained study, or may

emerge incrementally.

Failure to agree on the requirements and define them adequately is one of the
biggest cause of so(ware projects failing.
Lecture 02 Software Process 6
 User Interface Design
• Usability is of great importance in many modern
applications and software systems. That requires
good user interface design.
• User interfaces need to be evaluated with users.
• This requires iterative development:
• Design the user interface
• Test with users
• Revise the user interface
• Repeat

Lecture 02 Software Process 7

 System and Program
Design
Design describes the system from the software developers'
viewpoint.
• System design:
• Establish a system architecture, both hardware and software, that
matches the requirements
• Program design:
• Represent the software functions in a form that can be transformed
into one or more executable programs

Preliminary user testing is often carried out as part of the design step.

Models are used to represent the requirements, system architecture, and

program design. This course teaches the basic concepts of the Unified
Modeling Language (UML).
Lecture 02 Software Process 8
 Implementation
Implementation (coding)
• The software design is realized as a set of programs or
program units.
• These software components may be written by the
development team, acquired from elsewhere, or modified
from existing components.
Program Testing
• Program testing by the development staff is an integral
part of implementation.
• Individual components are tested against the design.
• The components are integrated and tested against the
design as a complete system.
Lecture 02 Software Process 9
 Acceptance and Release
Acceptance testing:
• The system is tested against the requirements by the
client, often with selected customers and users.
Delivery and release:
• After successful acceptance testing, the system is
delivered to the client and released into production or
marketed to customers.

Lecture 02 Software Process 10

 Operation and
Maintenance
Operation:
• The system is put into practical use.
Maintenance:
• Errors and problems are identified and fixed.
Evolution:
• The system evolves over time as requirements change, to add
new functions, or adapt to a changing technical environment.
Phase out:
• The system is withdrawn from service.

This is sometimes called the Software Life Cycle

Lecture 02 Software Process 11
 Quality Control in all
Software Development
• Validating the requirements
• Validating the system and program design
• Usability testing
• Program testing
• Acceptance testing
• Bug fixing and maintenance

Some of these steps will be repeated many

times during the life of the system

Lecture 02 Software Process 12

 Categories of Testing
• The term “testing” is used in several different contexts,
which are easily confused:
User testing
• Versions of the user interface are tested by users. Their experience
may lead to changes in the requirements or the design.
Program testing
• The development team tests components individually (unit
testing) or in combination (system testing) against the design to
find bugs, etc.
Acceptance testing
• The client tests the final version of the system or parts of the
system against the requirements.

Lecture 02 Software Process 13

 Sequence of Process
Every software project will include these basic steps,
in some shape or form, but:
• The steps may be formal or informal
• The steps may be carried out in various sequences

Lecture 02 Software Process 14

 Software Development
Process
Major alternatives:
• In this course, we will look at four categories of software development
processes:
Waterfall model:
• Complete each process step before beginning the next.
Iterative refinement:
• Go quickly through all the steps to create a rough system, then repeat
them to improve the system.
Spiral:
• A variant of iterative refinement in which new and updated components
are added to the developing system as they are completed.
Agile development:
• Small increments of so(ware are developed in a sequence of sprints,
each of which creates deployable code.
Lecture 02 Software Process 15