The Water Fall Model / Liner Sequential Development Model:

1) Introduction Waterfall model

2) When to use waterfall model
3) Waterfall model phases
4) Advantages of waterfall model
5) Disadvantages of waterfall model

Introduction Waterfall model:

Winston Royce introduced the waterfall model in 1970
Also called as Liner Sequential Development Model
Waterfall approach was first SDLC Model, used widely in Software Engineering to ensure
success of project.
Each phase must be completed, before the next phase can begin. Output of one phase will be
input of next phase.
This model is named “Waterfall model”, because its diagrammatic representation of cascading
waterfalls.

When to use Waterfall Model:

When the requirements are constant not changed regularly.
Application is not complicated and big.
A project is short and simple.
Where the tools and technology used is consistent and its not changing.
When resources are well prepared and are available to use.

Waterfall Model Phases:

1) Requirement & Analysis
2) Design
 3) Development
4) Testing
5) Deployment
6) Maintenance

Requirement & Analysis:

Every software project starts with COMMUNICATION phase between client and other stake holders.
The aim of this phase is to understand the exact requirements from the client and to document
them properly.
They discuss functions (features of the project, modules in the project), performance (Accuracy,
Portability), and interfacing (GUI) requirement of the software.
All the requirements collected in a document is called, Software Requirement Specification (SRS)
It contained a detailed description of what the system will do in the common language.
SRS document serves as a contract between the company and client.

Design Phase:
SRS document send forward to the design phase.
Design phase handled by UI & UX team.
All gathered requirements are converted into suitable design.
It defines overall software architecture together with high level and detailed design.
High level design includes Algorithm, Flow charts, Decision Tree, Database design etc.
Low level design includes Rough paper design, User interface components etc.
Also finalized programming languages, Database, Hardware and other software requirements.
All this work is documented as a Software Design Document (SDD).

Development Phase:
In this phase software design is translated into source code, by using any suitable programming
language.
The developer first develops the small programs called units / modules after that integrated it.
Unit test is done in every phase, to check whether each module is working properly or not.

Testing Phase:
In this phase, Tester perform all the testing activities to make sue that the system meets the client
requirements or not.
After combining all the unit modules, Integration testing is done for any faults and failures.
In case of any Bugs, report it.
It generates the Test cases & Test reports.

Deployment:
The product is deployed in the client environment or released into the market.

Maintenance Phase:
In maintenance phase, there are some issues which come up in the client environment.
To fix those issues, patches are released.
Also, to enhance the product some better versions are released.
Maintenance is done to deliver these changes in the client environment.

Advantages of Waterfall Model:

1) Simple and easy to understand and use.
2) Before the next phase of development, each phase must be completed.
3) Works well for smaller projects.
4) Requirements are very well understood & fixed.
5) Any changes in software is made during the process of the development.
6) Process and results are well documented.

Disadvantages:
1) High amount of risk and uncertainty
2) Error can be fixed only during the phase.
3) Not suitable for the projects where requirements are changing.
4) It becomes very difficult to move back to the phase.
5) Not a good model for complex and object-oriented projects.
6) Clients valuable feedback cannot be included with ongoing development phase.

Incremental process model:

Incremental Model is a process of software development where requirements divided into multiple
standalone modules of the software development cycle. In this model, each module goes through
the requirements, design, implementation and testing phases. Every subsequent release of the
module adds function to the previous release. The process continues until the complete system
achieved.

1) Introduction Incremental model

2) When to use Incremental model
3) Incremental model phases
4) Advantages of Incremental model
5) Disadvantages of Incremental model
Introduction Incremental model:
In Incremental model, requirements divided into multiple standalone modules of the
software development cycle.

Each module goes through the requirements, analysis, design, development, testing,
implementation, testing and deployment phases.
Every subsequent release of the module adds function to the previous release.
The process continues until the complete project achieved.

Imagine developing a mobile shopping app using the incremental model.

First, you create a basic version allowing users to view products and add them to a cart, then deliver
it to customers for feedback.
Next, you add user registration, login, and checkout features, releasing this updated version.
Subsequent increments include payment options, order tracking, and product search, each delivered
to customers.
Further enhancements, like user reviews and wish lists, are added in later iterations.
This process continues until the app is fully developed, with customers benefiting from early use and
continuous improvements

When to use Incremental model:

Requirements are clearly specified, understood and are known up-front.
When the client demands a quick release of the product.
You can develop prioritized requirements first.
A project has a long development schedule.
When software team are not very well skilled or trained.
Lowers initial delivery cost.
Such methodology is more use for web application and product-based companies.

X+Y=Z => X, X+, X+Y, X+Y=, X+Y=Z

Incremental Process Model Phases:
1) Requirement Gathering & Analysis
2) Design & Development Phase
3) Testing
4) Implementation

Requirement Gathering & Analysis:

Business Analyst & Product Manager collect all the functional & Non Functional requirements from
the client.
This phase performs a “Crucial role in Incremental Model”

Design & Development Phase:

Company designs the overall software architecture together with high level and detailed design.
Developers design the Algorithm, Data Flow diagram, Activity diagram, Class diagram, State
Transition diagram, Database design etc.

Testing Phase:
In this testing phase, Tester check the performance of each existing function as well as additional
functionality as per the client requirements or not.
There are many test methods, but the most common are White Box, Black Box and Grey Box test
methods.

Implementation:
Implementation phase enables the coding phase of the development system. It involves the final
coding that design in the designing and development phase and tests the functionality in the testing
phase. After completion of this phase, the number of the product working is enhanced and upgraded
up to the final system product

Advantages of Incremental Process Model

The Client gets important functionality early.
Clients have a clear idea of the project.
Errors are easy to be recognized.
Easier to test and debug.
Simple to manage risk, because it handled during its iteration.
Changes are easy to implement.
It is flexible and less expensive to change requirements and scope.
Partial systems are successively built to produce a final total system / project.
Disadvantages of Incremental Process Model:
Well defined module interfaces are needed.
A good team and proper planned execution are required, because of its continuous iterations.
Problems might cause due to system architecture as such not all requirements collected up front for
entire software lifecycle.
Each iteration phase is rigid and does not overlap each other.

Spiral Model:
1) Introduction to Spiral Model
2) Phases of Spiral Model
3) When to use Spiral Model
4) Advantages of Spiral Model
5) Disadvantages of Spiral Model

Introduction to Spiral Model:

Initially proposed by Boehm in 1986.
Also called as Meta model.
Spiral model generally used in Large Projects, Projects which have lot of risks, and the problems.
Spiral model is a Risk-Driven software development process model
It is a combination of Waterfall model, Iterative model and Prototype model.
Software is developed in a Series of incremental releases as per each spiral.
Ex: Microsoft, OS Versions, Gaming industry etc

The Spiral Model is a Software Development Life Cycle (SDLC) model that provides a systematic and
iterative approach to software development. In its diagrammatic representation, looks like a spiral
with many loops. The exact number of loops of the spiral is unknown and can vary from project to
project. Each loop of the spiral is called a phase of the software development process.
1. The exact number of phases needed to develop the product can be varied by the project
manager depending upon the project risks.
2. As the project manager dynamically determines the number of phases, the project manager
has an important role in developing a product using the spiral model.
 3. It is based on the idea of a spiral, with each iteration of the spiral representing a complete
software development cycle, from requirements gathering, analysis, design,
implementation, testing, and maintenance.

Phases of Spiral Model:

1) Planning
2) Risk Analysis
3) Engineering & Execution
4) Customer Evolution
1) Planning (Requirement Gathering & Analysis)
Communication between Client and Project Head
Collect all the requirements from the customers.
Analyses estimated cost, schedule & required resources

2) Risk Analysis
Identification of all the potential risks
Risk mitigation strategy is planned for solving risks.
Design a prototype of the model.

3) Engineering & Execution

Actual development starts
Designer designs the product as per the final prototype.
Developer perform actual coding for implementation
Tester perform all testing methods.
Deploy or Release the product to the customer environment.

4) Customer Evolution
In the evaluation phase, the software is evaluated to determine if it meets the customer’s
requirements and if it is of high quality.
Take feedback from the client.
If client want any changes, goes to next planning OR next spiral iteration.

When to use Spiral Model:

1. When the project is large & high budget.
2. When requirements are unclear and complex.
3. Where the software needs continuous risk evaluation.
4. When creation of a prototype is applicable.
5. When changes may require at any time.
6. When long term project commitment is not feasible due to changes in economic priorities

Advantages of Spiral Model:

1. High amount of risk analysis.
2. Risky parts can be developed earlier which helps in better risk management
3. Useful for large and mission-critical projects.
4. Allows extensive use of prototypes.
5. There is always a space for customer feedback
6. Changing requirements can be accommodated.
7. Development is fast.
Disadvantages of Spiral Modal:
1. Risk analysis needed highly particular expertise.
2. Can be a costly model to use.
3. Doesn't work well for smaller projects.
4. Spiral Process is complex sometimes because Spiral may go infinitely.
5. Large number of spiral stages requires excessive documentation.

Specialized Process Model:

A specialized process model in software engineering is a customized approach that addresses the
specific requirements, challenges, and constraints of a particular type of software project or
industry.

Various types of specialized model are:

1) Component based development
2) Formal methods model
3) Aspect oriented Software development

Component Based Development:

The commercial off-the-shelves components that are developed by the vendors are used during
the software built.
These components have specialized targeted functionalities and well-defined interfaces. Hence it
is easy to integrate these components into the existing software.

The components-based development model makes use of various characteristic of spiral model.
This model is evolutionary in nature. That means the necessary changes can be made in the software
during each iteration of software development cycle.

Before beginning the modelling and construction activity of software development the candidate
component must be searched and analysed. The components can be simple function or can be
object-oriented classes or methods.

Following Steps are applied for component-based development:

Identify the component-based products and analyse them for fitting in the existing application
domain.

Analyse the component integration issues.

Design the software architecture to accommodate the components.
Integrate the components into the software architecture.
Conduct comprehensive testing for the developed software.
Software re-usability is the major advantage of component-based development.
The re-usability reduces the development cycle time and overall cost.

Formal Methods Model:

This model consists of the set of activities in which the formal mathematical specification is used.
The software engineers specify, develop and test the computer-based systems using the
mathematical notation. The notation is specified within the formal methods.
Clean room software engineering makes use of the formal method approach.
The advantage of using formal methods model is the it overcomes many problems that we
encounter in traditional software process models. Ambiguity, incompleteness and inconsistency are
those problems that can be overcome if we use formal methods model.

The formal methods model offers defect-free software. However, there are some drawbacks of this
model which resists it form getting used widely. These drawbacks are.

The formal methods model is time consuming and expensive. For using this model, the developers
need the strong mathematical background or some extensive training. If this model is chosen for
development then the communication with customer becomes very difficult.

Aspect Oriented Software Development:

In traditional Software development process, the system is decomposed into multiple units of
primary functionality. But there are other issues of concern that do not fit into these primary
functionalities. Later on this becomes programmers duty to code modules corresponding to the
primary functionality and to incorporate all other concerned issues wherever appropriate.

Programmers need to keep in mind all the things that need to be done, how to deal with each issue,
the problems associated with them and the correct execution. Due to these concerns there are
chances of appearing serious problems during application development and maintenance. The
coding process for realizing a concern becomes very critical.

Aspect Oriented Software Development focuses on the identification, specification and

representation of cross-cutting concerns and into separate functional units as well as their
automated into a working system.
Aspect requirements define these cross-cutting concerns that have impact on the software
architecture.
Aspect Oriented Software Development is often referred as Aspect oriented programming.
It is a relatively new software engineering paradigm and is not matured enough. But is likely that it
will adopt the characteristics of both the spiral and concurrent process models.

Unified Process Model:

The Unified Process (UP) is a software development framework used for object-oriented modelling.
The unified process is an iterative and incremental software development process framework. The
framework is also known as Rational Unified Process (RUP) and the Open Unified Process (Open UP).

This a flexible and iterative approach to developing software. It focuses on creating working
software increments, collaborating with team members, and adapting to changes. It is based on the
Unified Modelling Language (UML) and is characterized by its use of use cases to drive development,
its focus on architecture-centric development, and its emphasis on risk management and
incremental delivery. UP is a flexible and adaptable process that can be tailored to meet the specific
needs of a project or organization, making it a popular choice for many software development teams
Key Principles of Unified Process
Iterative and Incremental: Unified Process divides the development process into multiple iterations,
with each iteration adding new functionality incrementally.

Use Case Driven: The use case-driven approach focuses on identifying the key interactions and
scenarios that a user will have with a system
The Unified Process focuses on identifying and prioritizing use cases that represent the system’s
functionality from the user’s perspective.

Architecture-Centric: The Unified Process emphasizes defining and refining the system architecture
throughout the development process.

Risk Management: Unified Process identifies and manages project risks proactively to minimize their
impact on the project’s success.

Continuous Validation: Unified Process ensures continuous validation of the system’s requirements,
design, and implementation through reviews, testing, and feedback.

Phases of Unified Process

1) Inception
2) Elaboration
3) Construction
4) Transition

Inception
The main goal of this phase involves delimiting the project scope. This is where we define why we
are making this product in the first place. It should have the following:
What are the key features?
How does this benefit the customers?
Which methodology will we follow?
What are the risks involved in executing the project?
Schedule and cost estimates.
Elaboration
In this phase, the project requirements are analysed in more detail, and the architecture of the
system is defined. Key activities include developing use cases, creating the architectural baseline,
identifying key components, and refining the project plan. The goal of this phase is to mitigate major
risks and establish a solid architectural foundation for the project.

Construction
This is the phase where the actual implementation of the system takes place. Key activities include
developing, testing, and integrating the system components, as well as continuously verifying that
the system meets the requirements. The goal of this phase is to build a complete, high-quality
software product that is ready for deployment.

Transition
This phase involves the deployment, multiple iterations, beta releases, and improvements of the
software. The users will test the software, which may raise potential issues. The development team
will then fix those errors.

Capability Maturity Model Integrity

The Software Engineering Institute (SEI) has developed a comprehensive model predicated
on a set of software engineering capabilities that should be present as organizations reach
different levels of process maturity. To determine an organization’s current state of process
maturity, the SEI uses an assessment that results in a five-point grading scheme.

The grading scheme determines compliance with a capability maturity model (CMM) [PAU93]
that defines key activities required at different levels of process maturity. The SEI approach
provides a measure of the global effectiveness of a company's software engineering practices
and establishes five process maturity levels that are defined in the following manner:

Level 1: Initial. The software process is characterized as ad hoc and occasionally even chaotic.
Few processes are defined, and success depends on individual effort.

Level 2: Repeatable. Basic project management processes are established to track cost,
schedule, and functionality. The necessary process discipline is in place to repeat earlier
successes on projects with similar applications.

Level 3: Defined. The software process for both management and engineering activities is
documented, standardized, and integrated into an organization wide software process. All
projects use a documented and approved version of the organization's process for developing
and supporting software. This level includes all characteristics defined for level 2.

Level 4: Managed. Detailed measures of the software process and product quality are
collected. Both the software process and products are quantitatively understood and
controlled using detailed measures. This level includes all characteristics defined for level 3.
Level 5: Optimizing. Continuous process improvement is enabled by quantitative feedback
from the process and from testing innovative ideas and technologies. This level includes all
characteristics defined for level 4.

The five levels defined by the SEI were derived as a consequence of evaluating responses to
the SEI assessment questionnaire that is based on the CMM. The results of the questionnaire
are distilled to a single numerical grade that provides an indication of an organization's
process maturity.