Lecture Two (2)

II. System/Software Development Life Cycle (SDLC)

Outline
 Software (System) development life cycle (SDLC)
 Software development life cycle Phases
 SDLC Models
 Waterfall model
 Cascading model
 Iterative model
 Spiral model
 V-shaped model
 Agile model

1. System development life cycle (SDLC)

SDLC is a framework that defines tasks performed at each step in the software
development process.

It cans also be defined as a systematic process for building software that ensures the
quality and correctness of the software built.

SDLC process aims to produce high-quality software that meets customer expectations.

2. System development life cycle (SDLC) Phases:

The SDLC has 7 standard phases which are:

Phase 1: Requirement collection and analysis:

The requirement is the first stage in the SDLC process. It is conducted by the senior team
members with inputs from all the stakeholders and domain experts in the industry.
Planning for the quality assurance requirements and recognition of the risks involved is
also done at this stage.

This stage gives a clearer picture of the scope of the entire project and the anticipated
issues, opportunities, and directives which triggered the project.
Requirements Gathering stage need teams to get detailed and precise requirements. This
helps companies to finalize the necessary timeline to finish the work of that system.

Phase 2: Feasibility study:

Once the requirement analysis phase is completed the next SDLC step is to define and
document software needs. This process conducted with the help of 'Software Requirement
Specification' document also known as 'SRS' document. It includes everything which
should be designed and developed during the project life cycle.

There are mainly five types of feasibilities checks:

 Economic: Can we complete the project within the budget or not?

 Legal: Can we handle this project within the legal framework of the area where the
software will be used?
 Operation feasibility: Can we create operations which is expected by the client?
 Technical: Need to check whether the current computer system can support the
software
 Schedule: Decide that the project can be completed within the given schedule or
not.

Phase 3: Design:
In this third phase, the system and software design documents are prepared as per the
requirement specification document. This helps define overall system architecture.

This design phase serves as input for the next phase of the model.

There are two kinds of design documents developed in this phase:

A. High-Level Design (HLD)

 Brief description and name of each module

 An outline about the functionality of every module
 Interface relationship and dependencies between modules
 Database tables identified along with their key elements
 Complete architecture diagrams along with technology details

B. Low-Level Design (LLD)

  Functional logic of the modules
 Database tables, which include type and size
 Complete detail of the interface
 Addresses all types of dependency issues
 Listing of error messages
 Complete input and outputs for every modules

Phase 4: Coding:
Once the system design phase is over, the next phase is coding. In this phase, developers
start build the entire system by writing code using the chosen programming language. In
the coding phase, tasks are divided into units or modules and assigned to the various
developers. It is the longest phase of the Software Development Life Cycle process.

In this phase, Developer needs to follow certain predefined coding guidelines. They also
need to use programming tools like compiler, interpreters, debugger to generate and
implement the code.

Phase 5: Testing:
Once the software is complete, and it is deployed in the testing environment. The testing
team starts testing the functionality of the entire system. This is done to verify that the
entire application works according to the customer requirement.

During this phase, QA and testing team may find some bugs/defects which they
communicate to developers. The development team fixes the bug and send back to QA for
a re-test. This process continues until the software is bug-free, stable, and working
according to the business needs of that system.

Phase 6: Installation/Deployment:
Once the software testing phase is over and no bugs or errors left in the system then the
final deployment process starts. Based on the feedback given by the project manager, the
final software is released and checked for deployment issues if any.
 Phase 7: Maintenance:
Once the system is deployed, and customers start using the developed system, following 3
activities occur

 Bug fixing - bugs are reported because of some scenarios which are not tested at
all
 Upgrade - Upgrading the application to the newer versions of the Software
 Enhancement - Adding some new features into the existing software

3. Software development life cycle Models

 Waterfall model
o Cascading model
 Iterative and incremental model
 Spiral model
 V-shaped model
 Agile model

1. Waterfall model
This model was the very first model 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, there is no overlapping of
phases.
 Figure 1: Waterfall Model

A slight modification of the Waterfall model or cascade life cycle model exist, which
offers the possibility of going back and reviewing previous stages. This was added on the
basis that inconsistences in one step only calls into question the previous step.

ADVANTAGES DISADVANTAGES

Simple to use and understand The software is ready only after the last stage is over

Management simplicity thanks to its rigidity: every High risks and uncertainty
phase has a defined result and process review

Development stages go one by one Not the best choice for complex and object-oriented
projects

Perfect for the small or mid-sized projects where Inappropriate for the long-term projects
requirements are clear and not equivocal

Easy to determine the key points in the The progress of the stage is hard to measure while it is
development cycle still in the development

Easy to classify and prioritize tasks Integration is done at the very end, which does not give
the option of identifying the problem in advance
2. Iterative and Incremental model
In this model, the iterative process starts with a simple implementation of a small set of
the software requirements and iteratively enhances the evolving versions until the
complete system is implemented and ready to be deployed.
An iterative life cycle model does not attempt to start with a full specification of
requirements. Instead, development begins by specifying and implementing just part of
the software, which is then reviewed to identify further requirements. This process is then
repeated, producing a new version of the software at the end of each iteration of the
model.

2.1. Iterative and Incremental Model Design

Iterative process starts with a simple implementation of a subset of the software
requirements and iteratively enhances the evolving versions until the full system is
implemented. At each iteration, design modifications are made and new functional
capabilities are added. The basic idea behind this method is to develop a system through
repeated cycles (iterative) and in smaller portions at a time (incremental).
The following illustration is a representation of the Iterative and Incremental model −

Figure 3: The iterative and Incremental Model

Iterative and Incremental development is a combination of both iterative design or

iterative method and incremental build model for development. "During software
development, more than one iteration of the software development cycle may be in
progress at the same time." This process may be described as an "evolutionary
acquisition" or "incremental build" approach."
In this incremental model, the whole requirement is divided into various builds. During
each iteration, the development module goes through the requirements, design,
implementation and testing phases. Each subsequent release of the module adds function
to the previous release. The process continues till the complete system is ready as per the
requirement.
The key to a successful use of an iterative software development lifecycle is rigorous
validation of requirements, and verification & testing of each version of the software
against those requirements within each cycle of the model. As the software evolves
through successive cycles, tests must be repeated and extended to verify each version of
the software.

2.2. Situations where Iterative and Incremental Model is highly-

Applicable
Like other SDLC models, Iterative and incremental development has some specific
applications in the software industry. This model is most often used in the following
scenarios −
 Requirements of the complete system are clearly defined and understood.
 Major requirements must be defined; however, some functionalities or requested
enhancements may evolve with time.
 There is a time to the market constraint.
 A new technology is being used and is being learnt by the development team while
working on the project.
 Resources with needed skill sets are not available and are planned to be used on
contract basis for specific iterations.
 There are some high-risk features and goals which may change in the future.

2.3. Advantages of the Iterative and Incremental SDLC Model −

 Some working functionality can be developed quickly and early in the life cycle.
 Results are obtained early and periodically.
 Parallel development can be planned.
 Progress can be measured.
  Less costly to change the scope/requirements.
 Testing and debugging during smaller iteration is easy.
 Risks are identified and resolved during iteration; and each iteration is an easily
managed milestone.
 Easier to manage risk - High risk part is done first.
 With every increment, operational product is delivered.
 Issues, challenges and risks identified from each increment can be utilized/applied
to the next increment.
 Risk analysis is better.
 It supports changing requirements.
 Initial Operating time is less.
 Better suited for large and mission-critical projects.
 During the life cycle, software is produced early which facilitates customer
evaluation and feedback.

2.4. Disadvantages of the Iterative and Incremental SDLC Model

 More resources may be required.
 Although cost of change is lesser, but it is not very suitable for changing
requirements.
 More management attention is required.
 System architecture or design issues may arise because not all requirements are
gathered in the beginning of the entire life cycle.
 Defining increments may require definition of the complete system.
 Not suitable for smaller projects.
 Management complexity is more.
 End of project may not be known which is a risk.
 Highly skilled resources are required for risk analysis.
 Projects progress is highly dependent upon the risk analysis phase.
3. verification and Validation Model (V-Model)
The V-Model (Verification and validation Model) is an extension of the waterfall model
and is based on the association of a testing phase for each corresponding development
stage. This means, for every single phase in the development cycle, there is a directly
associated testing phase. This is a highly-disciplined model and the next phase starts
only after completion of the previous phase.

Figure 4: V- Model

3.1. Situation in which V-Model is highly applicable.

 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.
3.2. Advantages of the V-Model method

 This is a highly-disciplined model and Phases are completed one at a

time.
 Works well for smaller projects where requirements are very well
understood.
 Simple and easy to understand and use.
 Easy to manage due to the rigidity of the model. Each phase has
specific deliverables and a review process.
3.3. Disadvantages of the V-Model
 High risk and uncertainty.
 Not a good model for complex and object-oriented projects.
 Poor model for long and ongoing projects.
 Not suitable for the projects where requirements are at a moderate to high risk of
changing.
 Once an application is in the testing stage, it is difficult to go back and change a
functionality.
 suffers from the problem of late verification of the proper functioning of the
system

4. Spiral life cycle model

The Spiral model is a combination of iterative development process model and sequential
linear development model i.e. the waterfall model with a very high emphasis on risk
analysis. It allows incremental releases of the product or incremental refinement through
each iteration around the spiral.

4.1. Spiral Model - Design

The spiral model has four phases. A software project repeatedly passes through these
phases in iterations called Spirals.

4.1.1.Identification
This phase starts with gathering the business requirements in the baseline spiral. In the
subsequent spirals as the product matures, identification of system requirements, and unit
requirements are all done in this phase.
The understanding of system requirements is done by continuous communication
between the customer and the system analyst. At the end of each spiral, a product is
deployed.

4.1.2.Design
The Design phase starts with the conceptual design in the baseline spiral and involves
architectural design, logical design of modules, physical product design and the final
design in the subsequent spirals.

4.1.3.Construct or Build
The Construct phase refers to production of the actual software product at every spiral.
In the baseline spiral, when the product is just thought of and the design is being
developed a POC (Proof of Concept) is developed in this phase to get customer feedback.
Then in the subsequent spirals with higher clarity on requirements and design details a
working model of the software called build is produced with a version number. These
builds are sent to the customer for feedback.

4.1.4. Evaluation and Risk Analysis

Risk Analysis includes identifying, estimating and monitoring the technical feasibility and
management risks, such as schedule slippage and cost overrun.
The following illustration is a representation of the Spiral Model, listing the activities in
each phase.
 Figure 5: Spiral Model

Based on the customer evaluation, the software development process enters the next
iteration and subsequently follows the linear approach to implement the feedback
suggested by the customer. The process of iterations along the spiral continues
throughout the life of the software.

4.2. Situations where the Spiral Model is highly Applicable

 When there is a budget constraint and risk evaluation is important.
 For medium to high-risk projects.
 Long-term project commitment because of potential changes to economic
priorities as the requirements change with time.
 Customer is not sure of their requirements which is usually the case.
 Requirements are complex and need evaluation to get clarity.
 New product line which should be released in phases to get enough customer
feedback.
 Significant changes are expected in the product during the development cycle.
4.3. Advantages of the Spiral Model
 Changing requirements can be accommodated.
 Allows extensive use of prototypes.
 Requirements can be captured more accurately.
 Users see the system early.
 Development can be divided into smaller parts and the risky parts can be
developed earlier which helps in better risk management.

4.4. Disadvantages of the Spiral Model −

 Management is more complex.
 End of the project may not be known early.
 Not suitable for small or low risk projects and could be expensive for small projects.
 Process is complex
 Spiral may go on indefinitely.
 Large number of intermediate stages requires excessive documentation.

The Agile model is a combination of iterative and incremental process models with
focus on process adaptability and customer satisfaction by rapid delivery of working
software product. Agile Methods break the product into small incremental builds. These
builds are provided in iterations. Each iteration typically lasts from about one to three
weeks. Every iteration involves cross functional teams working simultaneously on various
areas like −

 Planning
 Requirements Analysis
 Design
 Coding
 Unit Testing and
 Acceptance Testing.
 At the end of the iteration, a working product is displayed to the customer
and important stakeholders.

5. Agile life cycle Model

Agile model believes that every project needs to be handled differently and
the existing methods need to be tailored to best suit the project
requirements. In Agile, the tasks are divided to time boxes (small time
frames) to deliver specific features for a release.
Iterative approach is taken and working software build is delivered after each
iteration. Each build is incremental in terms of features; the final build holds
all the features required by the customer.

Figure 5: Agile Model

The Agile thought process had started early in the software development
and started becoming popular with time due to its flexibility and adaptability.
The most popular Agile methods include Rational Unified Process (1994),
Scrum (1995), Crystal Clear, Extreme Programming (1996), Adaptive Software
Development, Feature Driven Development, and Dynamic Systems
Development Method (DSDM) (1995). These are now collectively referred to
as Agile Methodologies, after the Agile Manifesto was published in 2001.
5.1. Agile Manifesto principles −

 Individuals and interactions − In Agile development, self-organization

and motivation are important, as are interactions like co-location and
pair programming.
 Working software − Demo working software is considered the best
means of communication with the customers to understand their
requirements, instead of just depending on documentation.
 Customer collaboration − As the requirements cannot be gathered
completely in the beginning of the project due to various factors,
continuous customer interaction is very important to get proper
product requirements.
 Responding to change − Agile Development is focused on quick
responses to change and continuous development.
5.2. Agile Vs Traditional SDLC Models

Agile is based on the adaptive software development methods, whereas the

traditional SDLC models like the waterfall model is based on a predictive
approach. Predictive teams in the traditional SDLC models usually work with
detailed planning and have a complete forecast of the exact tasks and
features to be delivered in the next few months or during the product life
cycle.
Predictive methods entirely depend on the requirement analysis and
planning done in the beginning of cycle. Any changes to be incorporated go
through a strict change control management and prioritization.
Agile uses an adaptive approach where there is no detailed planning and
there is clarity on future tasks only in respect of what features need to be
developed. There is feature driven development and the team adapts to the
changing product requirements dynamically. The product is tested very
frequently, through the release iterations, minimizing the risk of any major
failures in future.
Customer Interaction is the backbone of this Agile methodology, and open
communication with minimum documentation are the typical features of
Agile development environment. The agile teams work in close collaboration
with each other and are most often located in the same geographical
location.

5.3. Advantages of the Agile Model

 Is a very realistic approach to software development.

 Promotes teamwork and cross training.
 Functionality can be developed rapidly and demonstrated.
 Resource requirements are minimum.
 Suitable for fixed or changing requirements
 Delivers early partial working solutions.
 Good model for environments that change steadily.
 Minimal rules, documentation easily employed.
 Enables concurrent development and delivery within an overall planned
context.
 Little or no planning required.
 Easy to manage.
 Gives flexibility to developers.
5.4. Disadvantages of the Agile Model

 Not suitable for handling complex dependencies.

 More risk of sustainability, maintainability and extensibility.
  An overall plan, an agile leader and agile PM practice is a must without
which it will not work.
 Strict delivery management dictates the scope, functionality to be
delivered, and adjustments to meet the deadlines.
 Depends heavily on customer interaction, so if customer is not clear,
team can be driven in the wrong direction.
 There is a very high individual dependency, since there is minimum
documentation generated.
 Transfer of technology to new team members may be quite challenging
due to lack of documentation.

Assignment: Carry out an extensive research on other SDLC models such as

Prototype model, Big Bang Model and RAD Model.