Waterfall Model

1. Feasibility Study

The main goal of this phase is to determine whether it would be financially and technically feasible to
develop the software.

The feasibility study involves understanding the problem and then determining the various possible
strategies to solve the problem. These different identified solutions are analyzed based on their benefits
and drawbacks, The best solution is chosen and all the other phases are carried out as per this solution
strategy.

2. Requirements Analysis and Specification

The aim of the requirement analysis and specification phase is to understand the exact requirements of
the customer and document them properly. This phase consists of two different activities.

Requirement gathering and analysis: Firstly all the requirements regarding the software are gathered
from the customer and then the gathered requirements are analyzed. The goal of the analysis part is to
remove incompleteness (an incomplete requirement is one in which some parts of the actual
requirements have been omitted) and inconsistencies (an inconsistent requirement is one in which
some part of the requirement contradicts some other part).

Requirement specification: These analyzed requirements are documented in a software requirement

specification (SRS) document. SRS document serves as a contract between the development team and
customers. Any future dispute between the customers and the developers can be settled by examining
the SRS document.

3. Design

The goal of this phase is to convert the requirements acquired in the SRS into a format that can be
coded in a programming language. It includes high-level and detailed design as well as the overall
software architecture. A Software Design Document is used to document all of this effort (SDD)

4. Coding and Unit Testing

In the coding phase software design is translated into source code using any suitable programming
language. Thus each designed module is coded. The aim of the unit testing phase is to check whether
each module is working properly or not.

5. Integration and System testing

Integration of different modules is undertaken soon after they have been coded and unit tested.
Integration of various modules is carried out incrementally over a number of steps. During each
integration step, previously planned modules are added to the partially integrated system and the
resultant system is tested. Finally, after all the modules have been successfully integrated and tested,
the full working system is obtained and system testing is carried out on this.
The incremental model, also known as the Incremental Development Model, is a
software development approach that breaks down the software development
process into smaller, manageable phases. Each phase builds upon the previous
one, gradually adding new features and functionality to the software. This model
is particularly useful when requirements are not fully known upfront or when the
project involves evolving needs.
The phases of the incremental model typically include:
 Requirements Gathering: In this initial phase, the high-level requirements
for the software are gathered and analyzed. These requirements serve as a
foundation for the subsequent phases.
 Design: Based on the gathered requirements, the software's architecture,
design, and user interfaces are planned and developed. The design is often
divided into smaller segments to ensure a focused and organized
development process.
 Implementation: Each increment involves implementing a portion of the
software's functionality. Developers work on adding features, modules, or
components that were planned in the design phase. This incremental
approach allows for quicker delivery of usable software.
 Testing: As each increment is completed, testing is carried out to ensure
that the new features work as expected and do not negatively impact the
existing functionality. This ongoing testing helps catch and address issues
early in the development process.
 Integration: In this phase, the newly developed increments are integrated
into the existing software. This can involve merging code, resolving
conflicts, and ensuring that all components work together smoothly.
 Evaluation and Feedback: After each increment, stakeholders review the
functionality added and provide feedback. This feedback can be used to
refine the requirements, design, and implementation of subsequent
increments.
 Iterative Process: The software development process iterates through the
above phases, gradually adding new features and improvements. With each
iteration, the software becomes more robust and feature-rich.
What is RAD?

Rapid application development is a software development

methodology that uses minimal planning in favor of rapid
prototyping. A prototype is a working model that is functionally
equivalent to a component of the product.

In the RAD model, the functional modules are developed in parallel

as prototypes and are integrated to make the complete product for
faster product delivery. Since there is no detailed preplanning, it
makes it easier to incorporate the changes within the development
process.

RAD projects follow iterative and incremental model and have small
teams comprising of developers, domain experts, customer
representatives and other IT resources working progressively on
their component or prototype.

The most important aspect for this model to be successful is to

make sure that the prototypes developed are reusable.

RAD Model Design

RAD model distributes the analysis, design, build and test phases
into a series of short, iterative development cycles.

Following are the various phases of the RAD Model −

Business Modelling

The business model for the product under development is designed

in terms of flow of information and the distribution of information
between various business channels. A complete business analysis is
performed to find the vital information for business, how it can be
obtained, how and when is the information processed and what are
the factors driving successful flow of information.

Data Modelling

The information gathered in the Business Modelling phase is

reviewed and analyzed to form sets of data objects vital for the
business. The attributes of all data sets is identified and defined.
The relation between these data objects are established and defined
in detail in relevance to the business model.

Process Modelling

The data object sets defined in the Data Modelling phase are
converted to establish the business information flow needed to
achieve specific business objectives as per the business model. The
process model for any changes or enhancements to the data object
sets is defined in this phase. Process descriptions for adding,
deleting, retrieving or modifying a data object are given.

Application Generation

The actual system is built and coding is done by using automation

tools to convert process and data models into actual prototypes.

Testing and Turnover

The overall testing time is reduced in the RAD model as the

prototypes are independently tested during every iteration.
However, the data flow and the interfaces between all the
components need to be thoroughly tested with complete test
coverage. Since most of the programming components have already
been tested, it reduces the risk of any major issues.

The following illustration describes the RAD Model in detail.

Prototyping Model
Prototyping is defined as the process of developing a working replication of a product or system that has
to be engineered.

The Prototyping Model is one of the most popularly used Software Development Life Cycle Models
(SDLC models). This model is used when the customers do not know the exact project requirements
beforehand. In this model, a prototype of the end product is first developed, tested, and refined as per
customer feedback repeatedly till a final acceptable prototype is achieved which forms the basis for
developing the final product.

Steps Prototyping Model

Step 1: Requirement Gathering and Analysis: This is the initial step in designing a prototype model. In
this phase, users are asked about what they expect or what they want from the system.

Step 2: Quick Design: This is the second step in Prototyping Model. This model covers the basic design
of the requirement through which a quick overview can be easily described.

Step 3: Build a Prototype: This step helps in building an actual prototype from the knowledge gained
from prototype design.

Step 4: Initial User Evaluation: This step describes the preliminary testing where the investigation of the
performance model occurs, as the customer will tell the strength and weaknesses of the design, which
was sent to the developer.

Step 5: Refining Prototype: If any feedback is given by the user, then improving the client’s response to
feedback and suggestions, the final system is approved.

Step 6: Implement Product and Maintain: This is the final step in the phase of the Prototyping Model
where the final system is tested and distributed to production, here program is run regularly to prevent
failures.
Iterative Model
In this Model, you can start with some of the software specifications and develop the first version of the
software. After the first version if there is a need to change the software, then a new version of the
software is created with a new iteration. Every release of the Iterative Model finishes in an exact and
fixed period that is called iteration.

The Iterative Model allows the accessing earlier phases, in which the variations made respectively. The
final output of the project renewed at the end of the Software Development Life Cycle (SDLC) process.

The various phases of Iterative model are as follows:

1. Requirement gathering & analysis: In this phase, requirements are gathered from customers and
check by an analyst whether requirements will fulfil or not. Analyst checks that need will achieve within
budget or not. After all of this, the software team skips to the next phase.

2. Design: In the design phase, team design the software by the different diagrams like Data Flow
diagram, activity diagram, class diagram, state transition diagram, etc.

3. Implementation: In the implementation, requirements are written in the coding language and
transformed into computer programmes which are called Software.

4. Testing: After completing the coding phase, software testing starts using different test methods.
There are many test methods, but the most common are white box, black box, and grey box test
methods.
5. Deployment: After completing all the phases, software is deployed to its work environment.

6. Review: In this phase, after the product deployment, review phase is performed to check the
behaviour and validity of the developed product. And if there are any error found then the process
starts again from the requirement gathering.

7. Maintenance: In the maintenance phase, after deployment of the software in the working
environment there may be some bugs, some errors or new updates are required. Maintenance involves
debugging and new addition options.