Application/Software Development Life
Cycle Process and phases
Software Development Life Cycle (SDLC) is a framework that defines the
steps involved in the development of software at each phase. It covers the
detailed plan for building, deploying and maintaining the software.
SDLC defines the complete cycle of development i.e. all the tasks involved in
planning, creating, testing, and deploying a Software Product.
SDLC is a process that defines the various stages involved in the
development of software for delivering a high-quality product. SDLC stages
cover the complete life cycle of a software i.e. from inception to retirement
of the product.
Adhering to the SDLC process leads to the development of the software in a
systematic and disciplined manner.
Purpose:
Purpose of SDLC is to deliver a high-quality product which is as per the
customer’s requirement.
SDLC has defined its phases as, Requirement gathering, Designing, Coding,
Testing, and Maintenance. It is important to adhere to the phases to provide
the Product in a systematic manner.
For Example, A software has to be developed and a team is divided to work
on a feature of the product and is allowed to work as they want. One of the
developers decides to design first whereas the other decides to code first
and the other on the documentation part.
This will lead to project failure because of which it is necessary to have a
good knowledge and understanding among the team members to deliver an
expected product.
SDLC Cycle
SDLC Cycle represents the process of developing software.
Below is the diagrammatic representation of the SDLC cycle:
SDLC Phases
Given below are the various phases:
Requirement gathering and analysis
Design
Implementation or coding
Testing
Deployment
Maintenance
#1) Requirement Gathering and Analysis
During this phase, all the relevant information is collected from the customer
to develop a product as per their expectation. Any ambiguities must be
resolved in this phase only.
Business analyst and Project Manager set up a meeting with the customer to
gather all the information like what the customer wants to build, who will be
the end-user, what is the purpose of the product. Before building a product a
core understanding or knowledge of the product is very important.
#2) Design
In this phase, the requirement gathered in the SRS document is used as an
input and software architecture that is used for implementing system
development is derived.
#3) Implementation or Coding
Implementation/Coding starts once the developer gets the Design document.
The Software design is translated into source code. All the components of the
software are implemented in this phase.
#4) Testing
Testing starts once the coding is complete and the modules are released for
testing. In this phase, the developed software is tested thoroughly and any
defects found are assigned to developers to get them fixed.
Retesting, regression testing is done until the point at which the software is
as per the customer’s expectation. Testers refer SRS document to make sure
that the software is as per the customer’s standard.
#5) Deployment
Once the product is tested, it is deployed in the production environment or
first UAT (User Acceptance testing) is done depending on the customer
expectation.
#6) Maintenance
After the deployment of a product on the production environment,
maintenance of the product i.e. if any issue comes up and needs to be fixed
or any enhancement is to be done is taken care by the developers.
Software Development Life Cycle
Models
A software life cycle model is a descriptive representation of the software
development cycle. SDLC models might have a different approach but the
basic phases and activity remain the same for all the models.
#1) Waterfall Model
Waterfall model is the very first model that is used in SDLC. It is also known
as the linear sequential model.
In this model, the outcome of one phase is the input for the next phase.
Development of the next phase starts only when the previous phase is
complete.
#2) V-Shaped Model
V- Model is also known as Verification and Validation Model. In this model
Verification & Validation goes hand in hand i.e. development and testing
goes parallel. V model and waterfall model are the same except that the test
planning and testing start at an early stage in V-Model.
a) Verification Phase:
(i) Requirement Analysis:
In this phase, all the required information is gathered & analyzed.
Verification activities include reviewing the requirements.
(ii) System Design:
Once the requirement is clear, a system is designed i.e. architecture,
components of the product are created and documented in a design
document.
(iii) High-Level Design:
High-level design defines the architecture/design of modules. It defines the
functionality between the two modules.
(iv) Low-Level Design:
Low-level Design defines the architecture/design of individual components.
(v) Coding:
Code development is done in this phase.
b) Validation Phase:
(i) Unit Testing:
Unit testing is performed using the unit test cases that are designed and is
done in the Low-level design phase. Unit testing is performed by the
developer itself. It is performed on individual components which lead to early
defect detection.
(ii) Integration Testing:
Integration testing is performed using integration test cases in High-level
Design phase. Integration testing is the testing that is done on integrated
modules. It is performed by testers.
(iii) System Testing:
System testing is performed in the System Design phase. In this phase, the
complete system is tested i.e. the entire system functionality is tested.
(iv) Acceptance Testing:
Acceptance testing is associated with the Requirement Analysis phase and is
done in the customer’s environment.
#3) Prototype Model
The prototype model is a model in which the prototype is developed prior to
the actual software.
Prototype models have limited functional capabilities and inefficient
performance when compared to the actual software. Dummy functions are
used to create prototypes. This is a valuable mechanism for understanding
the customers’ needs.
Software prototypes are built prior to the actual software to get valuable
feedback from the customer. Feedbacks are implemented and the prototype
is again reviewed by the customer for any change. This process goes on until
the model is accepted by the customer.
Once the requirement gathering is done, the quick design is created and the
prototype which is presented to the customer for evaluation is built.
Customer feedback and the refined requirement is used to modify the
prototype and is again presented to the customer for evaluation. Once the
customer approves the prototype, it is used as a requirement for building the
actual software. The actual software is build using the Waterfall model
approach.
#4) Spiral Model
The Spiral Model includes iterative and prototype approach.
Spiral model phases are followed in the iterations. The loops in the model
represent the phase of the SDLC process i.e. the innermost loop is of
requirement gathering & analysis which follows the Planning, Risk analysis,
development, and evaluation. Next loop is Designing followed by
Implementation & then testing.
Spiral Model has four phases:
Planning
Risk Analysis
Engineering
Evaluation
(i) Planning:
The planning phase includes requirement gathering wherein all the required
information is gathered from the customer and is documented. Software
requirement specification document is created for the next phase.
(ii) Risk Analysis:
In this phase, the best solution is selected for the risks involved and analysis
is done by building the prototype.
For Example, the risk involved in accessing the data from a remote
database can be that the data access rate might be too slow. The risk can be
resolved by building a prototype of the data access subsystem.
(iii) Engineering:
Once the risk analysis is done, coding and testing are done.
(iv) Evaluation:
Customer evaluates the developed system and plans for the next iteration.
#5) Iterative Incremental Model
The iterative incremental model divides the product into small chunks.
For Example, Feature to be developed in the iteration is decided and
implemented. Each iteration goes through the phases namely Requirement
Analysis, Designing, Coding, and Testing. Detailed planning is not required in
iterations.
Once the iteration is completed, a product is verified and is delivered to the
customer for their evaluation and feedback. Customer’s feedback is
implemented in the next iteration along with the newly added feature.
Hence, the product increments in terms of features and once the iterations
are completed the final build holds all the features of the product.
Phases of Iterative & Incremental Development Model:
Inception phase
Elaboration Phase
Construction Phase
Transition Phase
(i) Inception Phase:
Inception phase includes the requirement and scope of the Project.
(ii) Elaboration Phase:
In the elaboration phase, the working architecture of a product is delivered
which covers the risk identified in the inception phase and also fulfills the
non-functional requirements.
(iii) Construction Phase:
In the Construction phase, the architecture is filled in with the code which is
ready to be deployed and is created through analysis, designing,
implementation, and testing of the functional requirement.
(iv) Transition Phase:
In the Transition Phase, the product is deployed in the Production
environment.
#6) Big Bang Model
Big Bang Model does not have any defined process. Money and efforts are
put together as the input and output come as a developed product which
might be or might not be the same as what the customer needs.
Big Bang Model does not require much planning and scheduling. The
developer does the requirement analysis & coding and develops the product
as per his understanding. This model is used for small projects only. There is
no testing team and no formal testing is done, and this could be a cause for
the failure of the project.
#7) Agile Model
Agile Model is a combination of the Iterative and incremental model. This
model focuses more on flexibility while developing a product rather than on
the requirement.
In Agile, a product is broken into small incremental builds. It is not developed
as a complete product in one go. Each build increments in terms of features.
The next build is built on previous functionality.
In agile iterations are termed as sprints. Each sprint lasts for2-4 weeks. At
the end of each sprint, the product owner verifies the product and after his
approval, it is delivered to the customer.
Customer feedback is taken for improvement and his suggestions and
enhancement are worked on in the next sprint. Testing is done in each sprint
to minimize the risk of any failures.