UNIT - 2

SOFTWARE LIFE CYCLE MODELS

ITERATIVE MODELS IN SOFTWARE ENGINEERING

The Iterative Model is a software development approach where the software is built and
improved through repeated cycles (iterations). Instead of developing the entire system at
once, it is developed in small parts, with each iteration refining and expanding the previous
version.

KEY FEATURES

1. Incremental Development – The system is developed in small sections, allowing

for early testing and feedback.

2. User Feedback – Each iteration is reviewed by users,

ensuring that requirements are met correctly.

3. Risk Management – Issues are identified and resolved in early stages.

4. Flexibility – Changes can be made in response to user needs and feedback.

PHASES OF ITERATIVE MODEL

1. Planning: Requirements are gathered, and initial design is created.

2. Design: A basic structure is designed based on initial requirements.

3. Implementation: A small part of the system is developed.

4. Testing: The developed portion is tested for bugs and issues.

5. Review & Feedback: Users evaluate the progress, and feedback is incorporated.

6. Iteration: Steps 2–5 are repeated, improving the software each cycle.

ADVANTAGES

Early detection of errors and risks.

Easier to accommodate changes.

Continuous user involvement ensures higher satisfaction.

DISADVANTAGES

Requires good planning and communication.

May lead to scope creep if changes are frequent.

Can be more expensive due to repeated development and testing.

EXAMPLES OF ITERATIVE MODELS

Agile Development: Focuses on rapid iterations and continuous improvement.

Rational Unified Process (RUP): A structured iterative approach used in large projects.

Iterative models are ideal for projects with evolving requirements and a need for continuous
improvements.

REQUIREMENT OF LIFE CYCLE MODELS IN SOFTWARE ENGINEERING

INTRODUCTION
Software development is a complex process that requires careful planning, execution, and
maintenance. To manage this complexity, Software Development Life Cycle (SDLC) models
provide a structured approach to developing software efficiently. These models define the
stages of software development, ensuring quality, reliability, and cost-effectiveness.

WHAT IS A SOFTWARE LIFE CYCLE MODEL?

A Software Life Cycle Model (SDLC Model) is a structured approach that outlines the
different stages of software development, from the initial idea to the final deployment and
maintenance. It ensures systematic development, reducing risks, errors, and unnecessary
costs.

Need for Life Cycle Models in Software Engineering

The requirement of SDLC models arises due to the following reasons:

1. Systematic Development Process

Software development involves multiple stages: requirement analysis, design,

implementation, testing, deployment, and maintenance. A life cycle model ensures these
stages are followed in an orderly manner, preventing confusion and ensuring clarity among
team members.

2. Improved Planning And Management

A structured approach allows for better planning and management of resources, timelines,
and costs. It helps project managers allocate tasks efficiently, estimate deadlines, and
minimize risks.

3. Risk Reduction

Developing software without a clear model increases risks such as cost overruns, missed
deadlines, and poor-quality output. SDLC models help mitigate these risks by introducing
systematic checks and validations at each stage.

4. Better Quality Assurance

Quality is crucial in software development. SDLC models include testing phases to identify
and fix defects early, ensuring the final product meets the required standards and functions
correctly.

5. Cost-Effectiveness

Developing software without a clear plan can lead to rework, delays, and increased costs.
Life cycle models help manage budget constraints by providing a clear roadmap for
development.
6. Customer Satisfaction

A structured development approach ensures that software meets customer expectations by

clearly defining requirements, validating designs, and continuously testing the product. This
leads to higher satisfaction and acceptance.

7. Scalability and Maintenance

Once deployed, software requires updates, bug fixes, and enhancements. A well-defined life
cycle model ensures the software is maintainable and scalable for future improvements.

8. Efficient Resource Allocation

Life cycle models help allocate human resources, tools, and technologies effectively,
preventing wastage and optimizing productivity.

COMMON SOFTWARE LIFE CYCLE MODELS

There are several SDLC models used in software engineering, each catering to different
project requirements:

1. Waterfall Model

A linear, sequential approach where each phase is completed before moving to the next.

Suitable for projects with well-defined requirements.

Disadvantage: Not flexible for changes.

2. Agile Model

Iterative development with frequent feedback from customers.

Suitable for dynamic and evolving requirements.

Disadvantage: Requires high collaboration and adaptability.

3. Spiral Model

Combines iterative development with risk management.

Suitable for complex and high-risk projects.

Disadvantage: Can be expensive and time-consuming.

4. V-Model (Validation & Verification Model)

Each development phase has a corresponding testing phase.

Ensures early defect detection.

Disadvantage: Rigid and not flexible for changes.

5. Prototype Model

A working prototype is developed before finalizing requirements.

Suitable for projects with unclear requirements.

Disadvantage: Requires extra effort to build prototypes.

PHASES OF THE WATERFALL MODEL

The Classic Waterfall Model is a traditional software development methodology that follows a
linear and sequential approach. It was introduced by Dr. Winston W. Royce in 1970 and is
one of the earliest models in software engineering. The model is called “Waterfall” because
progress flows downward like a waterfall through different phases, each of which must be
completed before moving to the next.

THE WATERFALL MODEL CONSISTS OF SIX MAIN PHASES:

1. Requirements Gathering and Analysis

In this phase, the project's requirements are collected from stakeholders, customers, and
users.

The requirements are documented in a Software Requirement Specification (SRS)

document.

This phase is crucial because any misunderstanding at this stage can lead to serious
problems later.

2. System Design
Based on the requirements from the first phase, the system architecture and design are
created.

This phase includes High-Level Design (HLD) and Low-Level Design (LLD):

HLD: Defines the overall system structure, modules, and technologies.

LLD: Focuses on module-level details, database design, and algorithms.

The design documents guide developers in the next phase.

3. Implementation (Coding)

Developers write code based on the design documents.

The system is divided into smaller modules, and each module is developed separately.

Programming languages, frameworks, and tools are chosen in this phase.

Unit testing is often performed to ensure individual components work correctly.

4. Testing

After coding is completed, the entire system undergoes testing.

Different testing methods are used:

Unit Testing: Tests individual components.

Integration Testing: Tests how different modules work together.

System Testing: Ensures the software meets requirements.

User Acceptance Testing (UAT): Performed by end users to validate functionality.

Bugs and errors are fixed before deployment.

5. Deployment

Once testing is completed, the software is deployed to production.

Deployment can be done in different ways, such as:

Pilot Deployment: Released to a limited number of users first.

Phased Deployment: Released in stages.

Full Deployment: Released to all users at once.

6. Maintenance

After deployment, software may require updates, bug fixes, and enhancements.

This phase includes three types of maintenance:

Corrective Maintenance: Fixing errors and bugs.

Adaptive Maintenance: Updating the software to work with new environments.

Perfective Maintenance: Enhancing features and improving performance.

ADVANTAGES OF THE WATERFALL MODEL

1. Simple and Easy to Understand – The linear structure makes it easy to follow.

2. Well-Defined Stages – Each phase has clear objectives and deliverables.

3. Better Documentation – Everything is well-documented, which helps in future reference.

4. Good for Small Projects – Works well when requirements are clear and stable.

5. Easy to Manage – Since phases do not overlap, it is easy to track progress.

DISADVANTAGES OF THE WATERFALL MODEL

1. Rigid and Inflexible – Changes cannot be made easily once a phase is completed.

2. Late Testing – Bugs are found late in the process, making them costly to fix.
3. Not Suitable for Complex Projects – Large projects often require flexibility and iterations.

4. High Risk – If requirements are misunderstood, the entire project can fail.

5. No Customer Feedback During Development – Customers only see the product at the
end.

WHEN TO USE THE WATERFALL MODEL?

When requirements are well-defined and unlikely to change.

When the project is small to medium-sized.

When the technology is stable and well understood.

When documentation is important, such as in government or healthcare projects.

PROTOTYPING MODELS IN SOFTWARE ENGINEERING

A Prototyping Model is a software development approach where a prototype (a working

model of the system) is created to visualize and refine requirements before actual
development. This helps both developers and users understand the system better, reducing
misunderstandings.

TYPES OF PROTOTYPING MODELS

1. Throwaway Prototyping – The prototype is discarded after gathering requirements, and

the final system is built from scratch.

2. Evolutionary Prototyping – The prototype is gradually refined based on feedback until it

becomes the final system.

3. Incremental Prototyping – The system is built in small parts (modules), each tested
separately.

4. Extreme Prototyping – Used in web applications, where a front-end prototype is

developed first, followed by back-end services.
ADVANTAGES

Helps clarify unclear requirements

Improves user involvement and feedback

Reduces development risks

DISADVANTAGES

Increases development time if not managed well

Users may misunderstand the prototype as the final product

EVOLUTIONARY MODELS IN SOFTWARE ENGINEERING

Evolutionary models focus on incremental development, allowing software to evolve through

multiple cycles. These models are useful when requirements are unclear or likely to change.

TYPES OF EVOLUTIONARY MODELS:

1. Incremental Model

Software is built in small parts (increments).

Each increment adds functionality.

Users can test earlier versions and give feedback.

Example: Developing an e-commerce website step by step.

2. Spiral Model

Combines prototyping and risk management.

Each phase involves planning, risk analysis, engineering, and evaluation.

Best for large, complex projects with high risks.

3. Prototyping Model
A working prototype is built quickly.

Users test and provide feedback.

Helps refine requirements before full development.

4. Agile Model

Divides work into small iterations (sprints).

Encourages continuous user involvement.

Example: Scrum and Kanban.

Advantages:

Flexible for changing requirements.

Early error detection.

Disadvantages:

May increase development cost.

Requires frequent user involvement.

SPIRAL MODEL IN SOFTWARE ENGINEERING

The Spiral Model is a software development process that combines iterative development
with risk management. It was introduced by Barry Boehm in 1986 and is often used for large,
complex projects.

Phases of the Spiral Model

1. Planning – Identify objectives, alternatives, and constraints.

2. Risk Analysis – Assess potential risks and find solutions.

3. Engineering – Develop and test the software incrementally.

4. Evaluation – Review and get feedback before proceeding.

Each cycle in the spiral represents a development phase. The process continues until the
final system is complete.

ADVANTAGES

Effective for managing risks.

Flexible and adaptable to changes.

Suitable for large, high-risk projects.

DISADVANTAGES

Expensive and time-consuming.

Requires skilled risk assessment.

The Spiral Model is ideal when risk management is crucial and project requirements evolve
frequently.

INTRODUCTION TO AGILE MODEL IN SOFTWARE ENGINEERING

Software engineering has evolved significantly over the years, with different models being
developed to enhance efficiency and adaptability. One such approach is the Agile Model,
which has transformed the way software is designed, developed, and deployed. Agile
focuses on flexibility, customer satisfaction, and iterative progress, making it a preferred
choice for many software development teams.

This article provides a detailed introduction to the Agile Model, its principles, methodology,
advantages, and challenges.

WHAT IS THE AGILE MODEL?

The Agile Model is a software development approach that promotes iterative development,
where requirements and solutions evolve through collaboration between cross-functional
teams. Unlike traditional development models, such as the Waterfall Model, Agile does not
follow a strict linear process. Instead, it encourages flexibility, frequent deliveries, and
continuous customer feedback.

Agile was introduced as an alternative to rigid development methodologies that struggled to

adapt to changing requirements. It became widely recognized with the publication of the
Agile Manifesto in 2001.

The Agile Manifesto and Principles

The Agile Manifesto was created by a group of 17 software developers who wanted to
improve software development efficiency. The manifesto outlines four key values and twelve
principles that define the Agile approach.

Four Key Values of Agile

1. Individuals and interactions over processes and tools

Agile emphasizes teamwork and direct communication rather than relying heavily on
documentation and formal tools.

2. Working software over comprehensive documentation

The priority is to deliver functional software rather than spending excessive time on detailed
documentation.

3. Customer collaboration over contract negotiation

Agile encourages continuous communication with customers to ensure their needs are met,
rather than just following a fixed contract.

4. Responding to change over following a plan

Agile embraces change at any stage of development to improve the product, unlike
traditional models that resist modifications once the plan is set.
Twelve Principles of Agile

1. Customer satisfaction is the highest priority.

2. Welcome changing requirements, even late in development.

3. Deliver working software frequently (in weeks, not months).

4. Collaboration between business and developers is crucial.

5. Build projects around motivated individuals and provide them the environment they need.

6. Face-to-face communication is the most effective form of communication.

7. Working software is the primary measure of progress.

8. Maintain a sustainable development pace.

9. Continuous attention to technical excellence and good design improves agility.

10. Simplicity—the art of maximizing the amount of work not done—is essential.

11. Self-organizing teams produce the best designs.

12. Regularly reflect and adjust behavior for better efficiency.

These principles serve as the foundation for Agile development and help teams deliver
high-quality software efficiently.

Agile Methodologies
Agile is not a single methodology but a collection of frameworks that follow Agile principles.
The most popular Agile methodologies include:

1. Scrum

Scrum is one of the most widely used Agile frameworks. It divides development into sprints
(short time-boxed iterations, usually 2–4 weeks). Each sprint results in a potentially
deliverable product.

Roles in Scrum:

Scrum Master – Facilitates the Scrum process.

Product Owner – Represents the customer and prioritizes requirements.

Development Team – Builds the product.

Scrum Process:

Sprint Planning – Define the work for the upcoming sprint.

Daily Standup – Short daily meeting to track progress.

Sprint Review – Present completed work to stakeholders.

Sprint Retrospective – Evaluate what went well and what needs improvement.

2. Kanban

Kanban is a visual-based Agile approach that focuses on continuous delivery without fixed
iterations. It uses a Kanban board with columns such as To Do, In Progress, and Done to
track work progress.

Key Features:

Visual representation of tasks.

Limits work in progress to avoid bottlenecks.

Continuous delivery without strict iterations.

3. Extreme Programming (XP)

Extreme Programming (XP) emphasizes high-quality code and customer involvement. It
encourages frequent releases, continuous testing, and pair programming (two developers
working together on the same code).

Key Features:

Test-driven development (TDD).

Small, frequent releases.

Continuous integration and refactoring.

4. Lean Development

Lean focuses on minimizing waste and maximizing value delivery. It is derived from
manufacturing principles and emphasizes efficiency, customer feedback, and rapid delivery.

Key Features:

Eliminate unnecessary work.

Deliver software as quickly as possible.

Empower development teams.

5. Feature-Driven Development (FDD)

FDD is an Agile approach that focuses on developing features in short iterations. It involves
defining a model, building features incrementally, and regularly reviewing progress.

Key Features:

Feature-based planning.

Small and frequent releases.

Continuous feedback.

Advantages of the Agile Model

1. Flexibility – Agile allows changes to requirements even in later development stages.

2. Customer Satisfaction – Regular customer involvement ensures the final product meets
expectations.

3. Faster Time to Market – Frequent releases enable quicker product launches.

4. Improved Collaboration – Agile promotes teamwork and direct communication.

5. Higher Quality – Continuous testing ensures bugs are fixed early.

6. Reduced Risks – Iterative development minimizes the chances of project failure.

Challenges of the Agile Model

1. Requires Active Customer Involvement – Frequent collaboration can be time-consuming.

2. Difficult to Predict Costs and Time – Agile’s flexibility makes cost estimation challenging.

3. Not Suitable for All Projects – Large, complex projects with strict regulations may struggle
with Agile.

4. Needs Experienced Teams – Agile requires skilled professionals who can adapt quickly.

5. Scope Creep – Continuous changes can lead to uncontrolled project expansion.

When to Use the Agile Model?

Agile is best suited for projects that:

Have evolving requirements.

Require frequent customer feedback.

Need quick and continuous releases.

Involve complex and dynamic environments.

Agile is commonly used in software startups, mobile app development, and web
applications, where adaptability is crucial.

COMPARISON OF DIFFERENT LIFE CYCLE MODELS IN SOFTWARE ENGINEERING

Software Development Life Cycle (SDLC) models provide a structured approach to software
development. Various models exist, each with strengths and weaknesses, making them
suitable for different projects. Below is a detailed comparison of the most common SDLC
models:

1. Waterfall Model

The Waterfall Model is the oldest and simplest SDLC model. It follows a linear and
sequential approach where each phase is completed before moving to the next.

Phases:

1. Requirement Gathering – Understanding client needs.

2. System Design – Planning architecture and components.

3. Implementation – Coding and unit testing.

4. Integration & Testing – Verifying functionality.

5. Deployment – Delivering the final product.

6. Maintenance – Fixing issues and updates.

Advantages:
Simple and easy to manage.

Well-documented process.

Suitable for small projects with well-defined requirements.

Disadvantages:

Difficult to accommodate changes.

Late-stage testing increases risk.

Unsuitable for complex, evolving projects.

2. V-Model (Validation and Verification Model)

The V-Model is an extension of the Waterfall Model where each development phase has a
corresponding testing phase.

Phases:

Similar to the Waterfall Model but each stage has an associated testing phase (e.g.,
requirement analysis → system testing).

Advantages:

Early detection of defects.

Testing is integrated into each phase.

Suitable for projects requiring high reliability.

Disadvantages:

Rigid structure makes it hard to modify.

High cost due to extensive testing.

Not ideal for projects with frequent requirement changes.

---

3. Incremental Model

The Incremental Model divides the project into smaller modules that are developed and
delivered in increments.

Phases:

Each increment follows the Waterfall approach but delivers a functional piece of the
software.

Advantages:

Easier debugging since small parts are developed.

Early delivery of useful software.

More flexibility in requirement changes.

Disadvantages:

Integration can be complex.

More planning required.

Costs may be higher than the Waterfall Model.

4. Spiral Model

The Spiral Model combines iterative development with risk assessment. It is best for
high-risk projects.

Phases (Repeated for each cycle):

1. Planning – Gathering requirements.

2. Risk Analysis – Identifying and mitigating risks.

3. Development – Coding and testing.

4. Evaluation – Feedback and decision-making.

Advantages:

Handles high-risk projects well.

Flexible and allows changes.

Early identification of issues.

Disadvantages:

High cost and time-consuming.

Requires expert risk assessment.

Not ideal for small projects.

5. Agile Model

The Agile Model is highly flexible and delivers software in iterative cycles, focusing on
customer feedback.

Phases (Iterative Sprints):

Planning → Design → Development → Testing → Deployment → Feedback.

Advantages:

Highly adaptable to changes.

Customer involvement ensures satisfaction.

Early and continuous software delivery.

Disadvantages:
Needs skilled developers.

Requires continuous client collaboration.

Less documentation compared to other models.

6. RAD Model (Rapid Application Development)

The RAD Model emphasizes rapid prototyping and quick feedback.

Phases:

1. Business Modeling – Understanding the business need.

2. Data Modeling – Structuring information flow.

3. Process Modeling – Creating a workflow.

4. Application Development – Building prototypes.

5. Testing & Deployment – Validating and deploying.

Advantages:

Faster development.

Encourages customer feedback.

Suitable for projects with dynamic requirements.

Disadvantages:

Requires skilled teams.

High resource demand.

Not ideal for complex, long-term projects.