1.4.2 Software Development Models

Software Development Models refer to the fundamental activities and approaches used in software development to plan, design, build, test, implement, and maintain software systems. These processes provide a structured framework for managing software projects.

Main Idea

Many software development models are available in the market. Each has its own advantages and disadvantages. The book discusses

the following two common models: Waterfall Model1. Agile Model2.

Core Concept

Waterfall Model The waterfall model is a sequential or linear development approach, in which development is seen as flowing steadily downwards (like a waterfall) through several phases. It is one of the most popular process models in software development. Developers use this approach when the requirements for a product are well-defined and resources are available. This model has five phases (as listed in the book): Requirements, Design, Development, Testing, Deployment, Maintenance. These steps always follow in this order and do not overlap. The developer must complete every phase before the next phase begins. This model is named "Waterfall Model" because its diagrammatic representation resembles a flow of waterfalls. Agile Model The Agile model is a software development process that is based on the iterative and incremental approach, emphasizing flexibility, collaboration, and customer feedback. The Agile model is a type of incremental model where software is developed in a rapid incremental cycle. This method breaks tasks into smaller iterations, or parts, and does not directly involve long-term planning. The project scope and requirements are laid down at the beginning of the development process. This model has six phases: Requirements gathering, Planning, Design, Implementation, Testing, Deployment, Maintenance.

Detailed Explanation

Waterfall Model — Phases 1. Requirements:

In this phase, the development team works on the feasibility of developing a software product. The aim of this phase is to understand the exact requirements of the customer and to document them properly. Both the customer and the software developer work together to document all the functions, performance, and interfacing requirements of the software. This takes place in two steps: Requirements Gathering and Analysis: The development team collects the essential requirements from all possible stakeholders and analyzes them. During the analysis, they eliminate incomplete and inconsistent requirements. Requirements Specification: After requirements analysis, the development team documents them in a Software Requirement Specification (SRS) document. It contains both functional and non-functional requirements of the software. 2. Design: In this step, the development team transforms requirements into a format that can be easily converted into code in a chosen programming language. It involves creating design documents specifying the different modules/components of the system, their interfacing, data flow, etc. All the data collected is stored in a Software Design Document (SDD) document. This document helps to establish the software's architecture. 3. Development: The Development phase involves the actual coding of the software based on the design specifications. During this phase, the design is implemented. If the SDD is complete, the coding phase proceeds smoothly because all the information needed by software developers is contained in the SDD. Developers use the detailed design documentation to write the necessary code, turning the conceptualized system into a functioning software product. 4. Testing:

During testing, the code is thoroughly tested for bugs and debugged or modified if required. After this, the Implementation (also called deployment) phase involves making the software in use in the real environment after it undergoes multiple rigorous tests. This phase is highly important as the quality of the end product is determined by the effectiveness of the testing carried out. The better output will lead to satisfied customers, lower maintenance costs, and accurate results. 5. Deployment: The Deployment phase involves making the software available in the intended environment for end-users. This includes activities such as installation, configuration, and data migration to ensure a smooth transition from the development environment to live production. It marks the point at which the software is ready for use. 6. Maintenance: Over a period of time, a software product may require some updates to remain functional in the real-world environment. The maintenance phase takes care of this activity by timely tuning the software as per the requirement. It is a very important phase of the waterfall development model. Even if the software is live and end users use it, it is essential to update it regularly. Two main types of maintenance: Corrective Maintenance: Involves correcting errors left undiscovered during the development and testing stages. Adaptive Maintenance (as described in the book's context): Entails enhancing the functionality of the software product as and when required, keeping in mind future trends and customer demands. Advantages of the Waterfall Model: It is perfectly suitable for projects where all the requirements are predefined and understood clearly. Requirements do not change throughout development. It is easy to understand and implement. All the activities to be performed in each phase are clearly defined.

The release date and the final cost are already estimated before the development begins. It is easier to assign tasks to different team members. All processes, actions, and results are well documented. Disadvantages of the Waterfall Model: Inflexibility to changes is a significant drawback, making mid-project adjustments challenging. Long delivery times are inherent as the entire project must be completed before delivery. High risk of project failure due to late client visibility and potential dissatisfaction. Late defect detection is a concern as testing is performed toward the end of development. Agile Model — Phases 1. Requirements Gathering: In the Agile software development model, the "Requirements Gathering" phase is characterized by continuous collaboration and dynamic responsiveness. Rather than relying on comprehensive upfront documentation, Agile teams engage in ongoing discussions with stakeholders. Through workshops, meetings, and iterative feedback sessions, the team identifies and prioritizes user stories, capturing requirements in a flexible and evolving manner . The emphasis is on adaptability, allowing for adjustments and refinements as the project progresses. 2. Planning: Agile planning is iterative and done in short cycles called sprints. The team, including developers and stakeholders, collaboratively plans the work for the upcoming sprint. Priorities are set, and tasks are pulled from the product backlog into the sprint backlog based on their importance and feasibility. Planning sessions are dynamic, allowing adjustments based on changing requirements. 3. Design:

The design phase in the Agile Model is a collaborative process that adapts to changing requirements and emerging insights. Unlike traditional approaches, Agile design activities are ongoing and occur at various levels throughout the development lifecycle. Cross-functional teams collaborate to design and refine features incrementally, ensuring that design decisions align with evolving project needs. This iterative approach allows for flexibility, facilitating the incorporation of feedback from stakeholders and team members. 4. Implementation: The implementation phase in the Agile Model involves developing the features identified in the design phase. Agile development occurs incrementally in short cycles known as sprints. During the "Development" phase, cross-functional teams implement prioritized user stories based on the sprint backlog. The focus is on delivering small, functional increments regularly, promoting adaptability to changing requirements. Collaboration within the team is crucial, fostering communication and shared understanding. Agile development principles prioritize customer satisfaction through the continuous delivery of tangible and valuable software. 5. Testing: In the Agile context, testing is an integral and continuous activity that happens in parallel with development. The "Testing" phase involves both automated and manual testing, ensuring that each increment is thoroughly validated. Testers collaborate closely with developers to identify and address issues promptly. The iterative nature of Agile allows for the early detection and resolution of defects, contributing to the overall quality of the product. 6. Deployment: The Deployment phase in Agile enables incremental and continuous delivery of product increments. Completed features are deployed/implemented to a staging environment for validation before being released to production. The emphasis is on ensuring a smooth and continuous delivery process that aligns with customer needs.

7. Maintenance: Maintenance in Agile involves addressing any issues identified after deployment. Regular review and feedback sessions characterize the "Maintenance" phase in Agile. At the end of each iteration, a sprint review is conducted to showcase completed features to stakeholders. This session provides an opportunity to gather feedback, assess the achieved goals, and discuss potential improvements. The iterative feedback loop ensures that the product evolves based on real-world usage and stakeholder insights, contributing to continuous improvement. Advantages of the Agile Model: Agile model offers flexibility and adaptability, allowing adjustments for evolving requirements. In this model, continuous client involvement ensures higher satisfaction. It enables early and incremental delivery of a functional product. Continuous improvement is facilitated through regular demonstrations. Improved communication is emphasized, fostering collaboration. Disadvantages of the Agile Model: Dependency on customer availability poses a challenge. The potential for scope creep exists with the flexibility to accommodate changes. Coordination challenges emerge with larger team sizes. Limited emphasis on documentation can be a drawback. Not ideal for projects with stable and well-defined requirements.

Important Points

• Software Development Models provide a structured framework for managing software projects.
• Waterfall Model: sequential/linear; requirements must be well-defined; phases do not overlap.
• Waterfall phases: Requirements, Design, Development, Testing, Deployment, Maintenance.
• Agile Model: iterative and incremental; emphasizes flexibility, collaboration, and customer feedback.
• Agile phases: Requirements Gathering, Planning, Design, Implementation, Testing, Deployment, Maintenance.
• Waterfall uses SRS (Software Requirement Specification) and SDD (Software Design Document).
• Waterfall maintenance types: Corrective and Adaptive.
• Agile planning is done in sprints; tasks move from product backlog to sprint backlog.
• Agile testing happens in parallel with development.
• Agile maintenance uses sprint reviews to gather feedback.

Remember

• Waterfall = sequential/linear; no overlap; complete one phase before next.
• Waterfall phases: Requirements Design Development Testing Deployment Maintenance.
• Agile = iterative/incremental; rapid cycles (sprints).
• Agile phases: Requirements Gathering Planning Design Implementation Testing Deployment Maintenance.
• SRS = Software Requirement Specification (Waterfall).
• SDD = Software Design Document (Waterfall).
• Waterfall maintenance = Corrective + Adaptive.
• Agile planning = sprints; product backlog sprint backlog.
• Agile testing runs in parallel with development.
• Agile maintenance uses sprint reviews.

Common Mistakes

• Thinking the Waterfall phases overlap. They do not overlap — each phase must be completed before the next begins.
• Confusing the Waterfall and Agile phase lists. Waterfall has "Requirements" and "Development"; Agile has "Requirements
• Gathering" and "Implementation".
• Forgetting that Agile planning uses sprints and backlogs (product backlog, sprint backlog).
• Thinking Agile testing happens only after development. In Agile, testing is continuous and parallel with development.
• Mixing up the two Waterfall documents: SRS (requirements) and SDD (design).
• Assuming Agile has no maintenance phase. Agile does include a Maintenance phase, using sprint reviews.
• Forgetting that Agile is not ideal for projects with stable and well-defined requirements.
• Confusing the two types of Waterfall maintenance: Corrective (fixing errors) and Adaptive (enhancing functionality).

Quick Revision

Software Development Models refer to the fundamental activities and approaches used in software development to plan, design, build, test, implement, and maintain software systems. These processes provide a structured framework for managing software projects. The book discusses two common models. The Waterfall model is a sequential or linear development approach in which development flows steadily downwards through several phases. It is used when requirements are well-defined and resources are available. The steps follow in order and do not overlap. The phases are Requirements, Design, Development, Testing, Deployment, and Maintenance. The Agile model is based on the iterative and incremental approach, emphasizing flexibility, collaboration, and customer feedback. It breaks tasks into smaller iterations (sprints). Its phases are Requirements Gathering, Planning, Design, Implementation, Testing, Deployment, and Maintenance. Both models have their own advantages and disadvantages.

60-Second Revision

Waterfall = sequential, linear , no overlap. Waterfall phases: Requirements Design Development Testing Deployment Maintenance. Agile = iterative, incremental, sprints. Agile phases: Requirements Gathering Planning Design Implementation Testing Deployment Maintenance. Waterfall docs: SRS + SDD; maintenance: Corrective + Adaptive.

Agile planning: product backlog sprint backlog; maintenance: sprint reviews. Warning: Waterfall phases do not overlap — each must be completed before the next begins.