Software Development Life Cycle Models
SDLC is a process followed for a software project, within a software organization. It consists
of a detailed plan describing how to develop, maintain, replace and alter or enhance specific
software. The life cycle defines a methodology for improving the quality of software and the
overall development process. There are various software development life cycle models
defined and designed which are followed during software development process. These
models are also referred as "Software Development Process Models". Each process model
follows a Series of steps unique to its type, in order to ensure success in process of software
development. Following are the most important and popular SDLC models followed in the
industry:
I.
Prescriptive Process Model
1. Waterfall Model
2. V-Model
II.
Incremental Process model
1. Incremental Model
2. RAD Model
III.
Evolutionary Process Model
1. Prototyping
2. Spiral Model
Prescriptive process model
1. Waterfall Model
The first published model of the software development process was derived from
other engineering process. This is illustrated from following figure. Because of the cascade
form one phase to another, this model is known as “water fall model “of software life cycle
model. The principal stages of the model map on to fundamental development activities.
Sometimes called the classic life cycle.Suggests a systematic, sequential (or linear) approach
to s/w development.
The oldest paradigm for s/w engineering Works best when –
1. Requirements of a problem are reasonably well understood
2. Well-defined adaptations or enhancements to an existing system must be
made
3. Requirements are well-defined and reasonably stable.
Waterfall Model Application
Every software developed is different and requires a suitable SDLC approach to be
followed based on the internal and external factors. Some situations where the use of
Waterfall model is most appropriate are:
 Requirements are very well documented, clear and fixed
 Product definition is stable
 Technology is understood and is not dynamic
 There are no ambiguous requirements
 Ample resources with required expertise are available to support the product
 The project is short
Waterfall Model Pros & Cons
Pros
Cons
Simple and easy to understand and
No working software is produced
Use.
until late during the life cycle.
Easy to manage due to the rigidity
High amounts of risk and
of the model – each phase has
uncertainty.
specific deliverables and a review
Not a good model for complex and
process.
object-oriented projects.
Phases are processed and
Poor model for long and ongoing
completed one at a time.
projects.
Works well for smaller projects
Not suitable for the projects where
where requirements are very well
requirements are at a moderate to
Understood.
high risk of changing. So risk and
Clearly defined stages.
uncertainty is high with this process
Well understood milestones.
model.
Easy to arrange tasks.
It is difficult to measure progress
within stages.
Process and results are well
Cannot accommodate changing
documented.
requirements.
No working software is produced
until late in the life cycle.
Adjusting scope during the life cycle
can end a project
Integration is done as a "big-bang” at
the very end, which doesn't allow
identifying any technological or
business bottleneck or challenges
V Model
V -Model is an extension of the waterfall model and is based on association of a
testing phase for each corresponding development stage. This means that for every single
phase in the development cycle there is a directly associated testing phase. This is a highly
disciplined model and next phase starts only after completion of the previous phase.
V- Model design
Under V-Model, the corresponding testing phase of the development phase is planned in
parallel. So there are Verification phases on one side of the ‘V’ and Validation phases on the
other side. Coding phase joins the two sides of the V-Model.
Validation Phases
Following are the Validation phases in V-Model:
 Unit Testing
Unit tests designed in the module design phase are executed on the code during this
validation phase. Unit testing is the testing at code level and helps eliminate bugs at an early
stage, though all defects cannot be uncovered by unit testing.
 Integration Testing
Integration testing is associated with the architectural design phase. Integration tests
are performed to test the coexistence and communication of the internal modules within the
system.
 System Testing
System testing is directly associated with the System design phase. System tests check
the entire system functionality and the communication of the system under development with
external systems. Most of the software and hardware compatibility issues can be uncovered
during system test execution.
 Acceptance Testing
Acceptance testing is associated with the business requirement analysis phase and
involves testing the product in user environment. Acceptance tests uncover the compatibility
issues with the other systems available in the user environment. It also discovers the non
functional issues such as load and performance defects in the actual user environment.
V- Model Application
V- Model application is almost same as waterfall model, as both the models are of sequential
type. Requirements have to be very clear before the project starts, because it is usually
expensive to go back and make changes. This model is used in the medical development
field, as it is strictly disciplined domain. Following are the suitable scenarios to use VModel:
•
Requirements are well defined, clearly documented and fixed.
•
Product definition is stable.
•
Technology is not dynamic and is well understood by the project team.
•
There are no ambiguous or undefined requirements
•
The project is short.
V- Model Pros and Cons
The advantage of V-Model is that it’s very easy to understand and apply. The simplicity of
this model also makes it easier to manage.
The disadvantage is that the model is not flexible to changes and just in case there is a
requirement change, which is very common in today’s dynamic world, it becomes very
expensive to make the change.
Pros
Cons
This is a highly disciplined model and High risk and uncertainty.
Phases are completed one at a time.
Not a good model for complex and
Works well for smaller projects where Object-oriented projects.
requirements are very well understood.
Simple and easy to understand and use.
Poor model for long and ongoing
projects.
Easy
to manage due to
the
rigidity
Not
suitable
for
the
projects
where
of the model – each phase has specific requirements are at a moderate to high risk of
deliverables and a review process.
changing.
Once an application is in the testing stage, it
is difficult to go back and change a
functionality
No working software is produced until late
during the life cycle
The incremental model combines elements of the linear sequential model (applied
repetitively) with the iterative philosophy of prototyping. Referring to figure, the incremental
model applies linear sequences in a staggered fashion as calendar time progresses. Each
linear sequence produces a deliverable “increment” of the software [MDE93]. For example,
word-processing software developed using the incremental paradigm might deliver basic file
management, editing, and document production functions in the first increment; more
sophisticated editing and document production capabilities in the second increment; spelling
and grammar checking in the third increment; and advanced page layout capability in the
fourth increment. It should be noted that the process flow for any increment can incorporate
the prototyping paradigm.
When an incremental model is used, the first increment is often a core product. That
is, basic requirements are addressed, but many supplementary features (some known, others
unknown) remain undelivered. The core product is used by the customer (or undergoes
detailed review). As a result of use and/or evaluation, a plain is developed for the next
increment. The plan addresses the modification of the core product to better meet the needs
of the customer and the delivery of additional features and functionality. This process is
repeated following the delivery of each increment, until the complete product is produced.
Incremental Process model
The incremental process model, like prototyping and other evolutionary approaches,
its iterative in nature. But unlike prototyping, the incremental model focuses on the delivery
of an operational product with each increment. Early increments are stripped down versions
of the final product, but they do provide capability that serves the user and also provide a
platform for evaluation by the user.
Incremental Model
Incremental development is particularly useful when staffing is unavailable for a
complete implementation by the business deadline that has been established for the project.
Early increments can be implemented with fewer people. If the core product is well received,
then additional staff (if required) can be added to implement the next increment. In addition,
increments can be planned to manage technical risks. For example, a major system might
require the availability of new hardware that is under development and whose delivery date is
uncertain. It might be possible to plan early increments in a way that avoids the use of this
hardware, thereby enabling partial functionality to be delivered to end-users without
inordinate delay.
The incremental model combines elements of the linear sequential model (applied
repetitively) with the iterative philosophy of prototyping. Referring to figure, the incremental
model applies linear sequences in a staggered fashion as calendar time progresses. Each
linear sequence produces a deliverable “increment” of the software [MDE93]. For example,
word-processing software developed using the incremental paradigm might deliver basic file
management, editing, and document production functions in the first increment; more
sophisticated editing and document production capabilities in the second increment; spelling
and grammar checking in the third increment; and advanced page layout capability in the
fourth increment. It should be noted that the process flow for any increment can incorporate
the prototyping paradigm.
When an incremental model is used, the first increment is often a core product. That
is, basic requirements are addressed, but many supplementary features (some known, others
unknown) remain undelivered. The core product is used by the customer (or undergoes
detailed review). As a result of use and/or evaluation, a plain is developed for the next
increment. The plan addresses the modification of the core product to better meet the needs
of the customer and the delivery of additional features and functionality. This process is
repeated following the delivery of each increment, until the complete product is produced.
RAD Model
[Rapid Application Development = RAD]
The iterations in RAD are 3 months or less, causing rapid succession of deliveries.
There can be multiple teams each working on one component. Each team takes 3 months or
less. The release combines these components. (See figure page 50 which shows 3 teams.)
Emphasizes a short development cycle
A “high speed” adaptation of the waterfall model
Uses a component-based construction approach
May deliver software within a very short time period (e.g. , 60 to 90 days) if requirements are
well understood and project scope is constrained
Prototyping
Customers may press for immediate delivery of working but inefficient products
The developer often makes implementation compromises in order to get a prototype working
quickly
Spiral Model
Couples the iterative nature of prototyping with the controlled and systematic aspects of the
waterfall model
It provides the potential for rapid development of increasingly more complete versions of the
software
It is a risk-driven process model generator
It has two main distinguishing features
1.Cyclic approach
Incrementally growing a system’s degree of definition and implementation while
decreasing its degree of risk
2. A set of anchor point milestones
A combination of work products and conditions that are attained along the path of the spiral
The spiral model, originally proposed by Boehm [BOE88], is an evolutionary
software process model that couples the iterative nature of prototyping with the controlled
and systematic aspects of the linear sequential model. It provides the potential for rapid
development of incremental versions of the software. Using the spiral mode, software is
developed in a series of incremental releases. During early iterations, the incremental release
might be a paper model or prototype. During later iterations, increasingly more complete
versions of the engineered system are produced.
A spiral model is divided into a number of framework activities, also called task
regions the spiral model discussed in this section is a variation on the model proposed by
Boehm. For further information on the original spiral mode, see [BOE88]. More recent
discussion of Boehm’s spiral model can be found in [BOE98]. Figure depicts a spiral model
that contains six task regions.

Customer communication – tasks required to establish effective communication
between developer and customer.

Planning – tasks required to define resources, timelines, and other project related
information.

Risk analysis – tasks required to assess both technical and management risks.

Engineering – tasks required to build one or more representations of the applications.

Construction and release – tasks required to construct, test, install, and provide user
support (e.g., documentation and training).

Customer evaluation – tasks required to obtain customer feedback based on evaluation
of the software representations created during the engineering stage and implemented
during the installation stage.
Each of the regions is populated by a set of work tasks, called a task set, that are
adapted to the characteristics of the project to be undertaken. For small projects, the number
of work tasks and their formality is low. For larger, more critical projects, each task region
contains more work tasks that are defined to achieve a higher level of formality. In all cases,
the umbrella activities (e.g., software configuration management and software quality
assurance) noted in section are applied.
As this evolutionary process begins, the software engineering team moves around the
spiral in a clockwise direction, beginning at the center. The first circuit around the spiral
might result in the development of a product specification; subsequent passes around the
spiral might be used to develop a prototype and then progressively more sophisticated
versions of the software. Each pass through the planning region results in adjustments to the
project plan. Cost and schedule are adjusted based on feedback derived from customer
evaluation. In addition, the project manager adjusts the planned number of iterations required
to complete the software.
Unlike classical process models that end when software is delivered, the spiral model
can be adapted to apply throughout the life of the computer software. An alternative view of
the spiral model can be considered by examining the project entry point axis, also shown in
figure. Each cube placed along the axis can be used to represent the starting point for
different types of projects. A “concept development project” starts at the core of the spiral
and will continue (multiple iterations occur along the spiral path that bounds the central
shaded region) until concept development is complete. If the concept is to be developed into
an actual product, the process proceeds through the next cube (new product development
project entry point) and a “new development project” is initiated. The new product will
evolve through a number of iterations around the spiral, following the path that bounds the
region that has somewhat lighter shading than core.
In essence, the spiral, when
characterized in this way, remains operative until the software is retired. There are times
when the process is dormant, but whenever a change is initiated, the process starts at the
appropriate entry point (e.g., product enhancement).
The spiral model is a realistic approach to the development of the large-scale systems
and software.
Because software evolves as the process progresses, the developer and
customer better understand and react to risks at each evolutionary level. The spiral model
uses prototyping as a risk reduction mechanism but, more important, enables the developer to
apply the prototyping approach at any stage in the evolution of the product. It maintains the
systematic stepwise approach suggested by the classic life cycle but incorporates it into an
iterative framework that more realistically reflects the real world. The spiral model demands
a direct consideration of technical risk at all stages of the project and, if properly applied,
should reduce risks before they become problematic.
But like other paradigms, the spiral model is not a panacea. It may be difficult to
convince customers (particularly in contract situations) that the evolutionary approach is
controllable. It demands considerable risk assessment expertise and relies on this expertise
for success. If a major risk is not uncovered and managed, problems will undoubtedly occur.
Finally, the model has not been used as a widely as the linear sequential or prototyping
paradigms.
It will take a number of years efficacy of this important paradigm can be
determined with absolute certainty.
13. Explain the Concurrent Development Model
The concurrent development model sometimes called concurrent engineering, has
been described in the following manner by Davis and Sitaram [DAV94]:
Project managers who track project status in terms of the major phases [of the classic
life cycle] have no idea of the status of their projects.
The concurrent process model can be represented schematically as a series of major
technical activities, tasks, and their associated states. For example, the engineering activity
defined for the spiral model is accomplished by invoking the following tasks: prototyping
and/or analysis modeling, requirements specification, and design. It should be noted that
analysis and design are complex tasks that require substantial discussion. Figure provides a
schematic representation of one activity with the concurrent process model. The activityanalysis-may be in any one the states. A state is some externally observable mode of
behavior noted at any given time.
Similarly other activities (e.g., design or customer
communication) can be represented in an analogous manner. All activities exist concurrently
but reside in different states. For example, early in a project the customer communication
activity (not shown in the figure) has completed its first iteration and exists in the awaiting
changes state. The analysis activity (which existed in the none state while initial customer
communication was completed) now makes a transition into the requirements must be made,
the analysis activity moves from the under development state into the awaiting changes state.
The concurrent process model defines a series of events that will trigger transitions
from state to state for each of the software engineering activities. For example, during early
states of design, an inconsistency in the analysis model is uncovered. This generates the
event analysis model correction which will trigger the analysis activity from the done state
into the awaiting changes state.