Ch.

3 Software Development Life Cycle

Content:
3.1 Introduction

3.2 Activities of SDLC

3.3 Generic Process Model

3.4 SDLC

3.5 Waterfall Model

3.6 Incremental Process Model

3.7 Prototyping Model

3.8 Spiral Model

3.1 Introduction:

Software Development Life Cycle (SDLC):

A software life cycle model (also termed process model) is a pictorial and diagrammatic
representation of the software life cycle. A life cycle model represents all the methods
required to make a software product transit through its life cycle stages. It also captures
the structure in which these methods are to be undertaken.

In other words, a life cycle model maps the various activities performed on a software
product from its inception to retirement. Different life cycle models may plan the necessary
development activities to phases in different ways. Thus, no element which life cycle model
is followed, the essential activities are contained in all life cycle models though the action
may be carried out in distinct orders in different life cycle models. During any life cycle
stage, more than one activity may also be carried out.

 SDLC is the acronym of Software Development Life Cycle.

 It is also called as Software Development Process.
  SDLC is a framework defining tasks performed at each step in the software
development process.
 ISO/IEC 12207 is an international standard for software life-cycle processes. It aims
to be the standard that defines all the tasks required for developing and maintaining
software.
“ISO (the International Organization for Standardization) and IEC
(the International Electrotechnical Commission) form the specialized system for
worldwide standardization.”

Need of SDLC:

The development team must determine a suitable life cycle model for a particular plan and
then observe to it.

Without using an exact life cycle model, the development of a software product would not
be in a systematic and disciplined manner. When a team is developing a software product,
there must be a clear understanding among team representative about when and what to
do. Otherwise, it would point to chaos and project failure. This problem can be defined by
using an example. Suppose a software development issue is divided into various parts and
the parts are assigned to the team members. From then on, suppose the team
representative is allowed the freedom to develop the roles assigned to them in whatever
way they like. It is possible that one representative might start writing the code for his part,
another might choose to prepare the test documents first, and some other engineer might
begin with the design phase of the roles assigned to him. This would be one of the perfect
methods for project failure.

A software life cycle model describes entry and exit criteria for each phase. A phase can
begin only if its stage-entry criteria have been fulfilled. So without a software life cycle
model, the entry and exit criteria for a stage cannot be recognized. Without software life
cycle models, it becomes tough for software project managers to monitor the progress of
the project.
3.2 Activities of SDLC:
SDLC provides a series of steps to be followed to design and develop a software product
efficiently. SDLC framework includes the following steps:

Communication:

 This is the first step where the user initiates the request for a desired software
product. He contacts the service provider and tries to negotiate the terms. He
submits his request to the service providing organization in writing.

Requirement Gathering

 This step onwards the software development team works to carry on the project.
The team holds discussions with various stakeholders from problem domain and
tries to bring out as much information as possible on their requirements. The
requirements are contemplated and segregated into user requirements, system
requirements and functional requirements. The requirements are collected using a
number of practices as given -

 studying the existing or obsolete(outdated) system and software,

 conducting interviews of users and developers,
  referring to the database or
 Collecting answers from the questionnaires.

Feasibility Study:

 After requirement gathering, the team comes up with a rough plan of software
process.
 At this step the team analyzes if software can be made to fulfill all requirements of
the user and if there is any possibility of software being no more useful.
 It is found out, if the project is financially, practically and technologically feasible for
the organization to take up.
 There are many algorithms available, which help the developers to conclude the
feasibility of a software project.

System Analysis:

 At this step the developers decide a roadmap of their plan and try to bring up the
best software model suitable for the project.
 System analysis includes Understanding of software product limitations, learning
system related problems or changes to be done in existing systems beforehand,
identifying and addressing the impact of project on organization and personnel etc.
 The project team analyzes the scope of the project and plans the schedule and
resources accordingly.

Software Design:

 Next step is to bring down whole knowledge of requirements and analysis on the
desk and design the software product.
 The inputs from users and information gathered in requirement gathering phase are
the inputs of this step.
 The output of this step comes in the form of two designs; logical design and physical
design.
 Engineers produce meta-data and data dictionaries, logical diagrams, data-flow
diagrams and in some cases pseudo codes.
Coding:

 This step is also known as programming phase.

 The implementation of software design starts in terms of writing program code in
the suitable programming language and developing error-free executable programs
efficiently.

Testing:

 An estimate says that 50% of whole software development process should be tested.
 Errors may ruin the software from critical level to its own removal.
 Software testing is done while coding by the developers and thorough testing is
conducted by testing experts at various levels of code such as module testing,
program testing, product testing, in-house testing and testing the product at user’s
end.
 Early discovery of errors and their remedy is the key to reliable software.

Integration:

 Software may need to be integrated with the libraries, databases and other
program(s).
 This stage of SDLC is involved in the integration of software with outer world
entities.

Implementation:

 This means installing the software on user machines. At times, software needs post-
installation configurations at user end.
 Software is tested for portability and adaptability and integration related issues are
solved during implementation.

Operation and Maintenance:

 This phase confirms the software operation in terms of more efficiency and less
errors.
 If required, the users are trained on, or aided with the documentation on how to
operate the software and how to keep the software operational.
 The software is maintained timely by updating the code according to the changes
taking place in user end environment or technology.
  This phase may face challenges from hidden bugs and real-world unidentified
problems.

Disposition:

 As time elapses, the software may decline on the performance front. It may go
completely obsolete or may need intense upgradation.
 Hence a pressing need to eliminate a major portion of the system arises.
 This phase includes archiving data and required software components, closing
down the system, planning disposition activity and terminating system at
appropriate end-of-system time.

3.3 Generic Process Model:

The generic process model is an abstraction of the software development process. It is
used in most software since it provides a base for them.

The generic process model encompasses the following five steps:

1. Communication
2. Planning
3. Modelling
4. Construction
5. Deployment
Communication:

In this step, we communicate with the clients and end-users.

 We discuss the requirements of the project with the users.

 The users give suggestions on the project. If any changes are difficult to implement,
we work on alternative ideas.
Planning:

In this step, we plan the steps for project development. After completing the final
discussion, we report on the project.

 Planning plays a key role in the software development process.

 We discuss the risks involved in the project.
Modelling:

In this step, we create a model to understand the project in the real world. We showcase
the model to all the developers. If changes are required, we implement them in this step.

 We develop a practical model to get a better understanding of the project.

Construction:

In this step, we follow a procedure to develop the final product.

 If any code is required for the project development, we implement it in this phase.
 We also test the project in this phase.
Deployment:

In this phase, we submit the project to the clients for their feedback and add any missing
requirements.

 We get the client feedback.

 Depending on the feedback form, we make the appropriate changes.
3.4 Software Development Life Cycle (SDLC):

A typical Software Development Life Cycle consists of the following stages:

Stage1: Planning and requirement analysis:

 Requirement Analysis is the most important and necessary stage in SDLC.

 The senior members of the team perform it with inputs from all the stakeholders
and domain experts or SMEs (Small and Medium-sized Enterprise) in the industry.
 Planning for the quality assurance requirements and identifications of the risks
associated with the projects is also done at this stage.
 Business analyst and Project organizer set up a meeting with the client to gather all
the data like what the customer wants to build, who will be the end user, what is the
objective of the product. Before creating a product, a core understanding or
knowledge of the product is very necessary.
  For Example, A client wants to have an application which concerns money
transactions. In this method, the requirement has to be precise like what kind of
operations will be done, how it will be done, in which currency it will be done, etc.

 Once the required function is done, an analysis is complete with auditing the
feasibility of the growth of a product. In case of any ambiguity, a signal is set up for
further discussion.
 Once the requirement is understood, the SRS (Software Requirement Specification)
document is created. The developers should thoroughly follow this document and
also should be reviewed by the customer for future reference.

Stage2: Defining Requirements:

 Once the requirement analysis is done, the next stage is to certainly represent and
document the software requirements and get them accepted from the project
stakeholders.
 This is accomplished through "SRS"- Software Requirement Specification document
which contains all the product requirements to be constructed and developed
during the project life cycle.

Stage3: Designing the Software:

 The next phase is about to bring down all the knowledge of requirements, analysis,
and design of the software project. This phase is the product of the last two, like
inputs from the customer and requirement gathering.

Stage4: Developing the project:

 In this phase of SDLC, the actual development begins, and the programming is built.
The implementation of design begins concerning writing code. Developers have to
follow the coding guidelines described by their management and programming tools
like compilers, interpreters, debuggers, etc. are used to develop and implement the
code.
Stage5: Testing:

 After the code is generated, it is tested against the requirements to make sure that
the products are solving the needs addressed and gathered during the requirements
stage.
 During this stage, unit testing, integration testing, system testing, acceptance testing
are done.

Stage6: Deployment:

 Once the software is certified, and no bugs or errors are stated, then it is deployed.
 Then based on the assessment, the software may be released as it is or with
suggested enhancement in the object segment.
 After the software is deployed, then its maintenance begins.

Stage7: Maintenance:

 Once when the client starts using the developed systems, then the real issues come
up and requirements to be solved from time to time.
 This procedure where the care is taken for the developed product is known as
maintenance.

3.5 Waterfall Model:

Waterfall model is an example of a Sequential model. In this model, the software

development activity is divided into different phases and each phase consists of a series of
tasks and has different objectives.

Waterfall model is the pioneer of the SDLC processes. In fact, it was the first model which
was widely used in the software industry. It is divided into phases and the output of one
phase becomes the input of the next phase. It is mandatory for a phase to be completed
before the next phase starts. In short, there is no overlapping in the Waterfall model

In waterfall, the development of one phase starts only when the previous phase is
complete. Because of this nature, each phase of the waterfall model is quite precise and
well-defined. Since the phases fall from a higher level to a lower level, like a waterfall, it’s
named the waterfall model.

Phases of Classical Waterfall Model

Let us now learn about each of these phases in detail.

1. Feasibility Study

The main goal of this phase is to determine whether it would be financially and technically
feasible to develop the software.

The feasibility study involves understanding the problem and then determining the various
possible strategies to solve the problem. These different identified solutions are analyzed
based on their benefits and drawbacks. The best solution is chosen and all the other phases
are carried out as per this solution strategy.

2. Requirements Analysis and Specification

The aim of the requirement analysis and specification phase is to understand the exact
requirements of the customer and document them properly. This phase consists of two
different activities.
  Requirement gathering and analysis: Firstly all the requirements regarding the
software are gathered from the customer and then the gathered requirements are
analyzed. The goal of the analysis part is to remove incompleteness (an incomplete
requirement is one in which some parts of the actual requirements have been
omitted) and inconsistencies (an inconsistent requirement is one in which some
part of the requirement contradicts some other part).
 Requirement specification: These analyzed requirements are documented in a
software requirement specification (SRS) document. SRS document serves as a
contract between the development team and customers. Any future dispute
between the customers and the developers can be settled by examining the SRS
document.

3. Design:

The goal of this phase is to convert the requirements acquired in the SRS into a format that
can be coded in a programming language. It includes high-level and detailed design as well
as the overall software architecture. A Software Design Document is used to document all
of this effort (SDD)

4. Coding and Unit Testing:

In the coding phase software design is translated into source code using any suitable
programming language. Thus each designed module is coded. The aim of the unit testing
phase is to check whether each module is working properly or not.

5. Integration and System testing:

Integration of different modules is undertaken soon after they have been coded and unit
tested. Integration of various modules is carried out incrementally over a number of steps.
During each integration step, previously planned modules are added to the partially
integrated system and the resultant system is tested. Finally, after all the modules have
been successfully integrated and tested, the full working system is obtained and system
testing is carried out on this.

System testing consists of three different kinds of testing activities as described below.
  Alpha testing: Alpha testing is the system testing performed by the development
team.
 Beta testing: Beta testing is the system testing performed by a friendly set of
customers.
 Acceptance testing: After the software has been delivered, the customer performed
acceptance testing to determine whether to accept the delivered software or reject
it.

6. Maintenance:

Maintenance is the most important phase of a software life cycle. The effort spent on
maintenance is 60% of the total effort spent to develop full software. There are basically
three types of maintenance.

 Corrective Maintenance: This type of maintenance is carried out to correct errors

that were not discovered during the product development phase.
 Perfective Maintenance: This type of maintenance is carried out to enhance the
functionalities of the system based on the customer’s request.
 Adaptive Maintenance: Adaptive maintenance is usually required for porting the
software to work in a new environment such as working on a new computer
platform or with a new operating system.

Why Do We Use the Waterfall Model?

The waterfall model is a software development model used in the context of large, complex
projects, typically in the field of information technology. It is characterized by a structured,
sequential approach to project management and software development.
The waterfall model is useful in situations where the project requirements are well-defined
and the project goals are clear. It is often used for large-scale projects with long timelines,
where there is little room for error and the project stakeholders need to have a high level of
confidence in the outcome.
Features of the Waterfall Model:

Sequential Approach:
 The waterfall model involves a sequential approach to software development,
where each phase of the project is completed before moving on to the next one.
Document-Driven:
 The waterfall model relies heavily on documentation to ensure that the project is
well-defined and the project team is working towards a clear set of goals.
Quality Control:
 The waterfall model places a high emphasis on quality control and testing at each
phase of the project, to ensure that the final product meets the requirements and
expectations of the stakeholders.
Rigorous Planning:
 The waterfall model involves a rigorous planning process, where the project scope,
timelines, and deliverables are carefully defined and monitored throughout the
project lifecycle.

3.6 Incremental Process Model:

 Mills Etal (1980) has suggested an alternative process model, which combines the
advantages of evolutionary prototyping with the control required for large-scale
development.
 Software is built in an incremental fashion.
 Incremental Model is a process of software development where requirements
divided into multiple standalone modules of the software development cycle.
 Each module goes through the requirements, design, implementation and testing
phases.
 Every subsequent release of the module adds function to the previous release.
 The process continues until the complete system achieved.
The various phases of incremental model are as follows:
1. Requirement analysis:
 In the first phase of the incremental model, the product analysis expertise identifies
the requirements.
 And the system functional requirements are understood by the requirement
analysis team.
 To develop the software under the incremental model, this phase performs a crucial
role.

2. Design & Development (Code):

 In this phase of the Incremental model of SDLC, the design of the system
functionality and the development method are finished with success.
 When software develops new practicality, the incremental model uses style and
development phase.
3. Testing:
 In the incremental model, the testing phase checks the performance of each existing
function as well as additional functionality.
  In the testing phase, the various methods are used to test the behavior of each task.
4. Implementation:
 Implementation phase enables the coding phase of the development system.
 It involves the final coding that design in the designing and development phase and
tests the functionality in the testing phase.
 After completion of this phase, the number of the product working is enhanced and
upgraded up to the final system product

When we use the Incremental Model?

 When the requirements are superior.
 A project has a lengthy development schedule.
 When Software team are not very well skilled or trained.
 When the customer demands a quick release of the product.
 You can develop prioritized requirements first.

Advantage of Incremental Model:

 Errors are easy to be recognized.
 Easier to test and debug
 More flexible.
 Simple to manage risk because it handled during its iteration.
 The Client gets important functionality early.

Disadvantage of Incremental Model

 Need for good planning
 Total Cost is high.
 Well defined module interfaces are needed.

3.7 Prototyping Model:

 Prototyping Model is a software development model in which prototype is built,
tested, and reworked until an acceptable prototype is achieved.
 It also creates base to produce the final system or software.
 It works best in scenarios where the project’s requirements are not known in detail.
  It is an iterative, trial and error method which takes place between developer and
client.
 It is based on the idea of developing an initial implementation, exposing this to user
comment and refining this through many versions until an adequate system has
seen developed.

3.7 Prototyping Model:

Listen to Built / Revise

Customer Mock-up

Customer Test –
Drives Mock-up

OR
Prototyping Model has following six SDLC phases as follow:

Step 1: Requirements gathering and analysis:

 A prototyping model starts with requirement analysis.
 In this phase, the requirements of the system are defined in detail.
 During the process, the users of the system are interviewed to know what their
expectation from the system is.
Step 2: Quick design:
 The second phase is a preliminary design or a quick design.
 In this stage, a simple design of the system is created.
 However, it is not a complete design.
 It gives a brief idea of the system to the user.
 The quick design helps in developing the prototype.
Step 3: Build a Prototype:
 In this phase, an actual prototype is designed based on the information gathered
from quick design.
 It is a small working model of the required system.
 In this stage, the proposed system is presented to the client for an initial evaluation.
 It helps to find out the strength and weakness of the working model.
 Comment and suggestion are collected from the customer and provided to the
developer.
Step 5: Refining prototype:
 If the user is not happy with the current prototype, you need to refine the prototype
according to the user’s feedback and suggestions.
 This phase will not over until all the requirements specified by the user are met.
 Once the user is satisfied with the developed prototype, a final system is developed
based on the approved final prototype.
Step 6: Implement Product and Maintain:
 Once the final system is developed based on the final prototype, it is thoroughly
tested and deployed to production.
 The system undergoes routine maintenance for minimizing downtime and prevent
large-scale failures.
Types of Prototyping Models:
Four types of Prototyping models are:
 Rapid Throwaway prototypes
 Evolutionary prototype
 Incremental prototype
 Extreme prototype

Rapid Throwaway prototypes:

 Rapid throwaway is based on the preliminary requirement.
 It is quickly developed to show how the requirement will look visually.
 The customer’s feedback helps drives changes to the requirement, and the
prototype is again created until the requirement is baseline.
 In this method, a developed prototype will be discarded and will not be a part of the
ultimately accepted prototype.
 This technique is useful for exploring ideas and getting instant feedback for
customer requirements.
Evolutionary Prototyping:
 Here, the prototype developed is incrementally refined based on customer’s
feedback until it is finally accepted.
 It helps you to save time as well as effort. That’s because developing a prototype
from scratch for every interaction of the process can sometimes be very frustrating.
 This model is helpful for a project which uses a new technology that is not well
understood.
 It is also used for a complex project where every functionality must be checked
once.
 It is helpful when the requirement is not stable or not understood clearly at the
initial stage.

Incremental Prototyping
 In incremental Prototyping, the final product is decimated into different small
prototypes and developed individually.
  Eventually, the different prototypes are merged into a single product. This method
is helpful to reduce the feedback time between the user and the application
development team.
Extreme Prototyping:
 Extreme prototyping method is mostly used for web development. It is consists of
three sequential phases.
 Basic prototype with all the existing page is present in the HTML format.
 You can simulate data process using a prototype services layer.
 The services are implemented and integrated into the final prototype.

3.8 Spiral Model:

The spiral model, initially proposed by Boehm (1988).
It is an evolutionary software process model that couples the iterative feature of
prototyping with the controlled and systematic aspects of the linear sequential model.
It implements the potential for rapid development of new versions of the software.
Using the spiral model, the software is developed in a series of incremental releases.
During the early iterations, the additional release may be a paper model or prototype.
During later iterations, more and more complete versions of the engineered system are
produced.
Each cycle in the spiral is divided into four parts:
Objectives determination and identify alternative solutions:
 Requirements are gathered from the customers and the objectives are identified,
elaborated, and analyzed at the start of every phase.
 Then alternative solutions possible for the phase are proposed in this quadrant.

Identify and resolve Risks:

 During the second quadrant, all the possible solutions are evaluated to select the
best possible solution.
 Then the risks associated with that solution are identified and the risks are resolved
using the best possible strategy.
 At the end of this quadrant, the Prototype is built for the best possible solution.

Develop the next version of the Product:

 During the third quadrant, the identified features are developed and verified
through testing.
 At the end of the third quadrant, the next version of the software is available.

Review and plan for the next Phase:

 In the fourth quadrant, the Customers evaluate the so-far developed version of the
software.
 In the end, planning for the next phase is started.

When To Use the Spiral Model?

 When a project is vast in software engineering, a spiral model is utilized.
 A spiral approach is utilized when frequent releases are necessary.
 When it is appropriate to create a prototype
 When evaluating risks and costs is crucial
 The spiral approach is beneficial for projects with moderate to high risk.
 The SDLC’s spiral model is helpful when requirements are complicated and
ambiguous.
 If modifications are possible at any moment
  When committing to a long-term project is impractical owing to shifting economic
priorities.

Advantages of the Spiral Model:

Below are some advantages of the Spiral Model.
Risk Handling:
 The projects with many unknown risks that occur as the development proceeds, in
that case, Spiral Model is the best development model to follow due to the risk
analysis and risk handling at every phase.
Good for large projects:
 It is recommended to use the Spiral Model in large and complex projects.
 Flexibility in Requirements:
 Change requests in the Requirements at a later phase can be incorporated
accurately by using this model.
Customer Satisfaction:
 Customers can see the development of the product at the early phase of the software
development and thus, they habituated with the system by using it before
completion of the total product.
Iterative and Incremental Approach:
 The Spiral Model provides an iterative and incremental approach to software
development, allowing for flexibility and adaptability in response to changing
requirements or unexpected events.
Emphasis on Risk Management:
 The Spiral Model places a strong emphasis on risk management, which helps to
minimize the impact of uncertainty and risk on the software development process.
Improved Communication:
 The Spiral Model provides for regular evaluations and reviews, which can improve
communication between the customer and the development team.
Improved Quality:
 The Spiral Model allows for multiple iterations of the software development
process, which can result in improved software quality and reliability.
Disadvantages of the Spiral Model:
Below are some main disadvantages of the spiral model.
Complex:
 The Spiral Model is much more complex than other SDLC models.
Expensive:
 Spiral Model is not suitable for small projects as it is expensive.
Too much dependability on Risk Analysis:
 The successful completion of the project is very much dependent on Risk Analysis.
 Without very highly experienced experts, it is going to be a failure to develop a
project using this model.
Difficulty in time management:
 As the number of phases is unknown at the start of the project, time estimation is
very difficult.
Complexity:
 The Spiral Model can be complex, as it involves multiple iterations of the software
development process.
Time-Consuming:
 The Spiral Model can be time-consuming, as it requires multiple evaluations and
reviews.
Resource Intensive:
 The Spiral Model can be resource-intensive, as it requires a significant investment in
planning, risk analysis, and evaluations.