INCREMENTAL MODEL:

Incremental Model is a process of software development where requirements are broken down

into multiple standalone modules of software development cycle. Incremental development is

done in steps from analysis design, implementation, testing/verification, maintenance.

Each iteration passes through the requirements, design, coding and testing phases. And each

subsequent release of the system adds function to the previous release until all designed

functionality has been implemented.

Requirement Analysis: Requirement and specification of the software are collected

Design: Some high-end function are designed during this stage

Code: Coding of software is done during this stage

Test: Once the system is deployed, it goes through the testing phase
The system is put into production when the first increment is delivered. The first increment is

often a core product where the basic requirements are addressed, and supplementary features are

added in the next increments. Once the core product is analyzed by the client, there is plan

development for the next increment.

Characteristics of an Incremental module includes:

 System development is broken down into many mini development projects
 Partial systems are successively built to produce a final total system

 Highest priority requirement is tackled first

 Once the requirement is developed, requirement for that increment are frozen

When to use Incremental models?

 Requirements of the system are clearly understood

 When demand for an early release of a product arises

 When software engineering team are not very well skilled or trained
 When high-risk features and goals are involved
 Such methodology is more in use for web application and product based
companies

Advantages:
 The software will be generated quickly during the software life cycle
 It is flexible and less expensive to change requirements and scope
 Throughout the development stages changes can be done
 This model is less costly compared to others
 A customer can respond to each building

 Errors are easy to be identified

Disadvantages:
 It requires a good planning designing
 Problems might cause due to system architecture as such not all requirements collected
up front for the entire software lifecycle
 Each iteration phase is rigid and does not overlap each other
 Rectifying a problem in one unit requires correction in all the units and consumes a lot of
time
SPIRAL MODEL:
The Spiral Model is one of the most important Software Development
Life Cycle models, which provides support for Risk Handling. In its
diagrammatic representation, it looks like a spiral with many loops. The
exact number of loops of the spiral is unknown and can vary from project
to project.

The exact number of phases needed to develop the product can be

varied by the project manager depending upon the project risks. As the
project manager dynamically determines the number of phases, the
project manager has an important role to develop a product using the
spiral model.

The Spiral Model is a Software Development Life Cycle (SDLC) model

that provides a systematic and iterative approach to software
development. It is based on the idea of a spiral, with each iteration of the
spiral representing a complete software development cycle, from
requirements gathering and analysis to design, implementation, testing,
and maintenance.

The Spiral model is called a Meta-Model because it subsumes all the

other SDLC models. For example, a single loop spiral actually represents
the Iterative Waterfall Model. The spiral model incorporates the stepwise
approach of the Classical Waterfall Model. The spiral model uses the
approach of the Prototyping Model by building a prototype at the start of
each phase as a risk-handling technique. Also, the spiral model can be
considered as supporting the Evolutionary model – the iterations along
the spiral can be considered as evolutionary levels through which the
complete system is built.
 Figure: Spiral Model
It has four stages or phases: The planning of objectives, risk analysis,
engineering or development, and finally review. A project passes through all
these stages repeatedly and the phases are known as a Spiral in the model.

1.Determine objectives and find alternate solutions – This phase includes

requirement gathering and analysis. Based on the requirements, objectives
are defined and different alternate solutions are proposed.

2.Risk Analysis and resolving – In this quadrant, all the proposed solutions
are analyzed and any potential risk is identified, analyzed, and resolved.

3.Develop and test: This phase includes the actual implementation of the
different features. All the implemented features are then verified with thorough
testing.

4.Review and planning of the next phase – In this phase, the software is
evaluated by the customer. It also includes risk identification and monitoring
like cost overrun or schedule slippage and after that planning of the next
phase is started.
Advantages:
 Risk Handling: The projects with many unknown risks that occur as
the development proceeds, in that case, Spiral Model is the best
development model to follow due to the risk analysis and risk handling
at every phase.
 Good for large projects: It is recommended to use the Spiral Model
in large and complex projects.
 Flexibility in Requirements: Change requests in the Requirements at
a later phase can be incorporated accurately by using this model.
 Customer Satisfaction: Customers can see the development of the
product at the early phase of the software development and thus, they
habituated with the system by using it before completion of the total
product.
 Iterative and Incremental Approach: The Spiral Model provides an
iterative and incremental approach to software development, allowing
for flexibility and adaptability in response to changing requirements or
unexpected events.
 Emphasis on Risk Management: The Spiral Model places a strong
emphasis on risk management, which helps to minimize the impact of
uncertainty and risk on the software development process.
 Improved Communication: The Spiral Model provides for regular
evaluations and reviews, which can improve communication between
the customer and the development team.
 Improved Quality: The Spiral Model allows for multiple iterations of
the software development process, which can result in improved
software quality and reliability.
(OR)
Advantages:

o High amount of risk analysis

o Useful for large and mission-critical projects.
Disadvantages:
 Complex: The Spiral Model is much more complex than other SDLC
models.
 Expensive: Spiral Model is not suitable for small projects as it is
expensive.
 Too much dependability on Risk Analysis: The successful
completion of the project is very much dependent on Risk Analysis.
Without very highly experienced experts, it is going to be a failure to
develop a project using this model.
 Difficulty in time management: As the number of phases is unknown
at the start of the project, time estimation is very difficult.
 Complexity: The Spiral Model can be complex, as it involves multiple
iterations of the software development process.
 Time-Consuming: The Spiral Model can be time-consuming, as it
requires multiple evaluations and reviews.
 Resource Intensive: The Spiral Model can be resource-intensive, as
it requires a significant investment in planning, risk analysis, and
evaluations.
(OR)
Disadvantages:

o Can be a costly model to use.

o Risk analysis needed highly particular expertise
o Doesn't work well for smaller projects.

When to use Spiral Model?

o When the project is large

o When requirements are unclear and complex
o When changes may require at any time
o Large and high budget projects
 AGILE METHODOLOGY
In the Agile model, the requirements are decomposed into many small parts that
can be incrementally developed. The Agile model adopts Iterative development.
Each incremental part is developed over an iteration. Each iteration is intended
to be small and easily manageable and can be completed within a couple of
weeks only. At a time one iteration is planned, developed, and deployed to the
customers. Long-term plans are not made.
Steps in the Agile Model

The agile model is a combination of iterative and incremental process models.

The steps involve in agile SDLC models are:

1. Requirement gathering
2. Design the Requirements
3. Construction / Iteration
4. Testing / Quality Assurance
5. Deployment
6. Feedback

1. Requirement Gathering:- In this step, the development team must gather the
requirements, by interaction with the customer. development team should plan
the time and effort needed to build the project. Based on this information you
can evaluate technical and economical feasibility.
2. Design the Requirements:- In this step, the development team will use user-
flow-diagram or high-level UML diagrams to show the working of the new
features and show how they will apply to the existing software. Wireframing and
designing user interfaces are done in this phase.
3. Construction / Iteration:- In this step, development team members start
working on their project, which aims to deploy a working product.
4. Testing / Quality Assurance:- Testing involves Unit Testing, Integration
Testing, and System Testing. A brief introduction of these three tests is as
follows:
5. Unit Testing:- Unit testing is the process of checking small pieces of code to
ensure that the individual parts of a program work properly on their own. Unit
testing is used to test individual blocks (units) of code.
 Integration Testing:- Integration testing is used to identify and resolve any
issues that may arise when different units of the software are combined.
 System Testing:- Goal is to ensure that the software meets the requirements
of the users and that it works correctly in all possible scenarios.
5. Deployment:- In this step, the development team will deploy the working
project to end users.
6. Feedback:- This is the last step of the Agile Model. In this, the team receives
feedback about the product and works on correcting bugs based on feedback
provided by the customer.
The time required to complete an iteration is known as a Time Box. Time-box
refers to the maximum amount of time needed to deliver an iteration to
customers. So, the end date for an iteration does not change. However, the
development team can decide to reduce the delivered functionality during a
Time-box if necessary to deliver it on time. The Agile model’s central principle
is delivering an increment to the customer after each Time-box.

Principles of the Agile Model

1. To establish close contact with the customer during development and to

gain a clear understanding of various requirements, each Agile project
usually includes a customer representative on the team. At the end of each
iteration stakeholders and the customer representative review, the progress
made and re-evaluate the requirements.
2. The agile model relies on working software deployment rather than
comprehensive documentation.
3. Frequent delivery of incremental versions of the software to the customer
representative in intervals of a few weeks.
4. Requirement change requests from the customer are encouraged and
efficiently incorporated.
5. It emphasizes having efficient team members and enhancing
communications among them is given more importance. It is realized that
improved communication among the development team members can be
achieved through face-to-face communication rather than through the
exchange of formal documents.
6. It is recommended that the development team size should be kept small (5
to 9 people) to help the team members meaningfully engage in face-to-face
communication and have a collaborative work environment.
7. The agile development process usually deploys Pair Programming. In Pair
programming, two programmers work together at one workstation. One
does coding while the other reviews the code as it is typed in. The two
programmers switch their roles every hour or so.
Characteristics of the Agile Process

 Agile processes must be adaptable to technical and environmental changes.

That means if any technological changes occur, then the agile process must
accommodate them.
 The development of agile processes must be incremental. That means, in each
development, the increment should contain some functionality that can be
tested and verified by the customer.
 The customer feedback must be used to create the next increment of the
process.
 The software increment must be delivered in a short span of time.
 It must be iterative so that each increment can be evaluated regularly.

When To Use the Agile Model?

 When frequent modifications need to be made, this method is implemented.

 When a highly qualified and experienced team is available.
 When a customer is ready to have a meeting with the team all the time.
 when the project needs to be delivered quickly.
 Projects with few regulatory requirements or not certain requirements.
 projects utilizing a less-than-strict current methodology
 Those undertakings where the product proprietor is easily reachable
 Flexible project schedules and budgets.

Advantages of the Agile Model

Here are some common pros/benefits of the Agile Model:

1. Communication with clients is on a one-on-one basis.

2. Provides a very realistic approach to software development
3. Agile Model in software engineering enables you to draft efficient designs
and meet the company’s needs.
4. Updated versions of functioning software are released every week.
5. It delivers early partial working solutions.
6. Changes are acceptable at any time.
7. You can reduce the overall development time by utilizing this Agile Model.
8. It allows concurrent development and delivery within an overall planned
context.
9. The final product is developed and available for use within a few weeks.
Disadvantages of Agile Model
Here are some common cons/drawbacks of the Agile Model:

1. There is a higher risk of sustainability, maintainability, and extensibility.

2. In some corporations, self-organization and intensive collaboration may not
be compatible with their corporate culture.
3. Documentation and design are not given much attention.
4. Without clear information from the customer, the development team can be
misled.
5. Not a suitable method for handling complex dependencies.