UNIT 1: SDLC MODELS

---

1. Introduction to SDLC Models

Different projects require different approaches. SDLC models define how phases are arranged and executed. Here are the most common SDLC models used in the industry:

Quick Links to Models:

• 1. Waterfall Model
• 2. Spiral Model
• 3. Incremental Model
• 4. Prototype Model
• 5. RAD Model

---

1. Waterfall Model

What is the Waterfall Model?

The Waterfall model, introduced by Winston W. Royce in 1970, is the earliest and most traditional SDLC approach. It is a linear-sequential life cycle model. In this model, each phase must be fully completed and reviewed before the next phase can begin. There is strict top-down flow, much like a waterfall, meaning you cannot easily go back to a previous phase once it is finished.

The choice of the waterfall model depends heavily on the certainty and stability of the application's requirements.

Phases of the Waterfall Model:

1. Feasibility Study: Assessing whether the software project is technically and financially practical.
2. Requirement Analysis and Specification: Gathering all exact requirements from the client and documenting them thoroughly in an SRS document.
3. Design and Specification: Creating the software architecture and physical design based on the gathered requirements.
4. Coding and Module Testing: Writing the actual program source code and testing individual units (modules) independently.
5. Integration and System Testing: Combining the tested modules to form the complete software system and testing it as a whole to ensure it meets requirements.
6. Delivery: Deploying the fully tested software to the customer or production environment.
7. Maintenance: Providing continuous support to fix post-deployment bugs and ensure smooth eventual operations.

Advantages of the Waterfall Model:

• Simple and Easy to Understand: The linear progression makes it very straightforward to manage and use.
• Well-Documented: Every phase requires rigorous documentation before moving forward, leaving a clear paper trail for new developers.
• Clear Milestones: Each stage has clearly defined start and end points with specific deliverables.
• Best for Small Projects: Highly effective for smaller projects where requirements are extremely clear and very unlikely to change.

Disadvantages of the Waterfall Model:

• Inflexible to Change: Once a phase is completed, it is very difficult and expensive to go back and make changes if requirements evolve.
• Late Testing Phase: Testing is done only after coding is completely finished. If a major design flaw is found late, fixing it is highly costly.
• No Early Prototypes: The client does not see a working version of the software until very late in the life cycle (the Delivery phase).
• Not Suitable for Complex Projects: Very poor choice for long, complex, or object-oriented projects where requirements are ambiguous or dynamic.

---

2. Spiral Model

What is the Spiral Model?

The Spiral model, originally proposed by Barry Boehm in 1986, is an evolutionary software process model that uniquely couples the iterative nature of prototyping with the systematic aspects of the linear sequential (Waterfall) model. It provides the potential for rapid development of increasingly more complete versions of the software.

The most distinguishing feature of the Spiral Model is its strong emphasis on risk assessment and risk management. The development process flows in a spiral pattern, where each loop or iteration around the spiral represents a phase of the software development process.

Phases of the Spiral Model (Quadrants):

Each loop of the spiral is split into four distinct quadrants:

1. Planning (Objective Setting): Identifying objectives, alternatives, and constraints. Requirements are gathered and understood during this phase.
2. Risk Analysis and Resolution: Evaluating alternatives and actively identifying and resolving critical risks. Prototyping is heavily used here to mitigate technical risks.
3. Engineering (Development and Testing): Developing the actual product features for the current iteration and thoroughly testing them.
4. Evaluation: Reviewing Phase results with the customer. The customer evaluates the software built in the previous quadrant and provides vital feedback for the next spiral loop.

Advantages of the Spiral Model:

• Excellent Risk Management: Uniquely suited for high-risk projects because risks are analyzed and mitigated at every single step.
• Flexibility in Changing Requirements: Accommodates late changes seamlessly since it is iteratively built. New features can be added in later loops.
• Customer Feedback: Continuous involvement of the customer throughout the lifecycles ensures the product meets their exact needs.
• Early Prototypes: Working prototypes are produced early in the life cycle, giving clients immediate visibility into the progress.

Disadvantages of the Spiral Model:

• Highly Complex: Considerably more complex to manage compared to other SDLC models.
• Expensive: Not suitable for small projects; it is costly to run due to the need for highly specialized risk-evaluation expertise.
• Time-Consuming: The spiral may go on indefinitely if risks are not properly managed, delaying final delivery.
• Dependent on Risk Experts: The success of the entire model relies heavily on the team's ability to accurately identify and manage risks early on.

---

3. Incremental Model

What is the Incremental Model?

The Incremental Model is a process of software development where requirements are divided into multiple standalone modules or "increments" of the software development cycle. In this model, each module passes through the requirements, design, implementation, and testing phases.

Every subsequent release of a module adds functionality to the previous release. The process continues until the complete, full-featured system is achieved. Think of it as a series of mini-Waterfalls where a piece of the software is built and delivered to the customer, and then another piece is added.

Process of the Incremental Model:

1. Requirement Analysis: Requirements are gathered for the entire system, but are prioritized and separated into specific functional chunks to be delivered gradually.
2. Design & Development (Per Increment): A specific piece of functionality (e.g., Build 1) is designed and coded.
3. Testing (Per Increment): The specific increment is rigorously tested.
4. Implementation & Delivery: The increment is delivered to the customer as a working, usable product.
   The cycle repeats for Build 2, Build 3, and so on until the final product is assembled.

Advantages of the Incremental Model:

• Early Delivery: Generates working software quickly and early during the software life cycle.
• Flexible to Changes: It is significantly easier and cheaper to change scope and requirements in this model than in Waterfall.
• Easier Testing & Debugging: Because the iterations are smaller, testing and debugging isolated increments is much easier.
• Lower Initial Risk: Customers get to experience core features early, lowering the risk of complete project failure.

Disadvantages of the Incremental Model:

• Requires Good Planning: Needs excellent overarching planning and architecture design to ensure all increments integrate properly at the end.
• Higher Total Cost: The overall cost of the project may be higher than a strictly linear model.
• Interface Dependencies: Requires very well-defined interfaces between modules because some modules will be developed long before others.

---

4. Prototype Model

What is the Prototype Model?

The Prototype Model is a systems development method in which a prototype (an early approximation of a final system or product) is built, tested, and then reworked as necessary until an acceptable prototype is finally achieved from which the complete system or product can now be developed.

This model works best in scenarios where not all of the detailed project requirements are known beforehand. It is an iterative, trial-and-error process that takes place between the developers and the users.

Process of the Prototype Model:

1. Requirement Gathering & Analysis: System requirements are defined in as much detail as possible. This usually involves interviewing a number of users representing all the departments or aspects of the existing system.
2. Quick Design: A preliminary design is created for the new system. It focuses on aspects of the software that will be visible to the user (e.g., input approaches and output formats).
3. Build Prototype: An initial prototype is created based on the Quick Design.
4. Customer Evaluation: The prototype is presented to the customer/users for thorough evaluation. They provide feedback on what they like and what needs changing.
5. Refining Prototype: If the user is unhappy, the prototype is refined according to feedback. Steps 3, 4, and 5 are repeated until the user is satisfied.
6. Engineer Product: Once the prototype is approved, the actual final software is engineered based on the prototype's specifications (it goes through design, coding, testing, and maintenance).

Advantages of the Prototype Model:

• Better Understanding of Requirements: Users are actively involved in development, ensuring the final system accurately reflects their needs.
• Early Defect Detection: Errors and missing functionality can be detected much earlier in the software lifecycle.
• Reduces Risk of Failure: Because the user has already approved a working model, the risk of delivering an unwanted product is virtually zero.
• User Feedback: Provides a mechanism for quick, continuous, and highly valuable feedback from actual end-users.

Disadvantages of the Prototype Model:

• Customer Confusion: Customers sometimes mistake a rough, quick prototype for the finished product and become frustrated when they can't immediately use it.
• Poor Developer Decisions: Developers might make quick, suboptimal technical choices to get the prototype working fast, which later negatively impacts the final product's architecture.
• Scope Creep: Endless loops of user feedback can lead to "scope creep," drastically extending the project timeline.

---

5. RAD Model

What is the RAD Model?

The Rapid Application Development (RAD) model is an agile-based software development life cycle model that heavily emphasizes extremely fast prototyping and iterative delivery over strict, linear planning (like Waterfall). It focuses on gathering requirements through focus groups and workshops, early testing of prototypes by customers using the iterative concept, reuse of existing software components, and rapid delivery of working products.

In the RAD model, the functional modules are developed in parallel as prototypes by different teams and are later integrated to make the complete product. Delivery times are strictly time-boxed.

Phases of the RAD Model:

1. Business Modeling: The business boundaries and workflows are defined. Information flow among business functions is established to understand where information comes from, where it goes, and how it is processed.
2. Data Modeling: The information gathered in Business Modeling is refined into a set of data objects needed to support the business. The attributes of these objects are identified and defined.
3. Process Modeling: The data objects defined in Data Modeling are transformed to achieve the information flow necessary to implement a specific business function. Processing descriptions are created to add, modify, delete, or retrieve data objects.
4. Application Generation: Automated tools are used to heavily convert process and data models directly into interactive prototypes and eventually working code.
5. Testing and Turnover: Because prototypes are independently tested during every iteration by the separate teams, the overall testing time in RAD is drastically reduced. Only the integrations between the modules need rigorous final testing.

Advantages of the RAD Model:

• Extreme Speed: Development time is significantly reduced compared to traditional models.
• Encourages Component Reuse: Code and components are highly reusable across modules, reducing duplicate work.
• Continuous Feedback: Frequent customer feedback ensures the product perfectly matches their immediate needs.
• Easy Integration: Since integrations are tested from the very beginning, final integration issues are extremely rare.

Disadvantages of the RAD Model:

• Requires Skilled Personnel: Requires highly skilled and experienced developers and designers who can handle fast-paced prototyping and parallel development.
• Needs Strong Team Collaboration: Due to the parallel nature of the teams, if communication breaks down, the final integration will fail.
• Not for All Systems: Only applicable for systems that can be modularized (broken down into distinct, independent parts).
• High Reliance on Tools: Heavily depends on modeling skills and automated code-generation tools.

---

Comparison of SDLC Models

---

Important Points for Exam

• SDLC is a systematic approach to system development.
• It ensures quality, cost control, and proper documentation.
• Each phase has specific activities.
• Different SDLC models are used based on project needs.

---

5-Mark Answer Structure

Define SDLC and explain its phases briefly.

---

10-Mark Answer Structure

Explain SDLC with phases, importance, and models.

Include:

• Definition
• Detailed explanation of phases
• Diagram
• Importance
• SDLC models
• Conclusion

---

Practice MCQs – SDLC Models

🎯 Start Practice MCQ Quiz →

---

---