Software Life Cycle
“What happens in the „life‟ of software”
The software process
A structured set of activities required to develop a
Many different software processes but all involve:
Specification – defining what the system should do;
Design and implementation – defining the organization of
the system and implementing the system;
Validation – checking that it does what the customer wants;
Evolution – changing the system in response to changing
A software process model is an abstract representation of
a process. It presents a description of a process from some
Software process models
The waterfall model
Plan-driven model. Separate and distinct phases of
specification and development.
Specification, development and validation are interleaved.
May be plan-driven or agile.
Reuse-oriented software engineering
The system is assembled from existing components. May be
plan-driven or agile.
In practice, most large systems are developed using a
process that incorporates elements from all of these
There are no right or wrong software processes.
The classic life cycle - oldest and most widely
Known as “Linear sequential model”
Activities „flow‟ from one phase to another
If there are corrections, return to a previous
phase and „flow‟ from there again
Major advantages: Good for planning and
Real projects rarely follow a sequential flow
Hard to state all requirements explicitly
No maintenance or evolution involved
Customer must have patience
Any blunder can be disastrous
Leads to “blocking states”
Each linear sequence produces a particular
“increment” to the software
First increment typically core product; more features
added by later increments
Allows flexible allocation of resources
Software separated into different “increments” complete working portions
Focus on delivery of operational product with each
increment - can be evaluated
Useful when insufficient staff and can be planned to
manage technical risks, e.g. waiting for new
The cost of accommodating changing customer
requirements is reduced.
It is easier to get customer feedback on the
development work that has been done.
More rapid delivery and deployment of useful
software to the customer is possible.
The process is not visible.
Managers need regular deliverables to measure
progress. If systems are developed quickly, it is not
cost-effective to produce documents that reflect every
version of the system.
System structure tends to degrade as new increments
Unless time and money is spent on refactoring to
improve the software, regular change tends to corrupt
its structure. Incorporating further software changes
becomes increasingly difficult and costly.
A horizontal prototype tests a particular layer
(typically the GUI) of the system
A vertical prototype tests a particular functionality
across all layers
Developer and customer determine objectives and
Prototype quickly produced and evaluated by
Prototype then refined, and re-evaluated
Process iterated, before final product development
Advantages: Customer participation and better
Customer may see prototype as working model and
expects fast results
Developer compromised when producing prototype
quickly, e.g. different operating system or
System is developed in series of evolutionary
Milestones for each iteration of the spiral
Process does not end with delivery
Reflects iterative nature of development
Originally proposed by Boehm, couples iterative
nature of prototyping and the systematic aspects of
Software is developed in series of incremental
Each iteration produces a more complete product
Better management through risk analysis(Modeling)
May be difficult to convince customers that
evolution is controllable
Demands risk assessment expertise - major risk will
cause problems if not identified
Relatively new and not widely used - cannot
Use of software tools that allow software engineer to
specify s/w characteristics at higher level
The tools generate codes based on specification
More time in design and testing - increase
Tools may not be easy to use, codes generated may
not be efficient
Software processes are the activities involved in producing a software
system. Software process models are abstract representations of
General process models describe the organization of software
processes. Examples of these general models include the „waterfall‟
model, incremental development, and reuse-oriented development.
Requirements engineering is the process of developing a software
Design and implementation processes are concerned with
transforming a requirements specification into an executable software
Software validation is the process of checking that the system
conforms to its specification and that it meets the real needs of the
users of the system.
Software evolution takes place when you change existing software
systems to meet new requirements. The software must evolve to