What is Software Engineering?

The term software engineering is the product of two words, software,

and engineering.

The software is a collection of integrated programs.

Software subsists of carefully-organized instructions and code written by

developers on any of various particular computer languages.

Computer programs and related documentation such as requirements, design

models and user manuals.

Engineering is the application of scientific and practical knowledge to invent,

design, build, maintain, and improve frameworks, processes, etc.

Software Engineering is an engineering branch related to the evolution of software

product using well-defined scientific principles, techniques, and procedures. The result
of software engineering is an effective and reliable software product.

Why is Software Engineering required?

Software Engineering is required due to the following reasons:

o To manage Large software

o For more Scalability
o Cost Management
o To manage the dynamic nature of software
o For better quality Management

Need of Software Engineering

The necessity of software engineering appears because of a higher rate of progress in
user requirements and the environment on which the program is working.

o Huge Programming: It is simpler to manufacture a wall than to a house or

building, similarly, as the measure of programming become extensive
engineering has to step to give it a scientific process.
o Adaptability: If the software procedure were not based on scientific and
engineering ideas, it would be simpler to re-create new software than to scale an
existing one.
o Cost: As the hardware industry has demonstrated its skills and huge
manufacturing has let down the cost of computer and electronic hardware. But
the cost of programming remains high if the proper process is not adapted.
o Dynamic Nature: The continually growing and adapting nature of programming
hugely depends upon the environment in which the client works. If the quality of
the software is continually changing, new upgrades need to be done in the
existing one.
o Quality Management: Better procedure of software development provides a
better and quality software product.

Importance of Software Engineering

The importance of Software engineering is as follows:

1. Reduces complexity: Big software is always complicated and challenging to

progress. Software engineering has a great solution to reduce the complication
of any project. Software engineering divides big problems into various small
issues. And then start solving each small issue one by one. All these small
problems are solved independently to each other.
2. To minimize software cost: Software needs a lot of hardwork and software
engineers are highly paid experts. A lot of manpower is required to develop
software with a large number of codes. But in software engineering,
programmers project everything and decrease all those things that are not
needed. In turn, the cost for software productions becomes less as compared to
any software that does not use software engineering method.
3. To decrease time: Anything that is not made according to the project always
wastes time. And if you are making great software, then you may need to run
many codes to get the definitive running code. This is a very time-consuming
procedure, and if it is not well handled, then this can take a lot of time. So if you
are making your software according to the software engineering method, then it
will decrease a lot of time.
 4. Handling big projects: Big projects are not done in a couple of days, and they
need lots of patience, planning, and management. And to invest six and seven
months of any company, it requires heaps of planning, direction, testing, and
maintenance. No one can say that he has given four months of a company to the
task, and the project is still in its first stage. Because the company has provided
many resources to the plan and it should be completed. So to handle a big
project without any problem, the company has to go for a software engineering
method.
5. Reliable software: Software should be secure, means if you have delivered the
software, then it should work for at least its given time or subscription. And if any
bugs come in the software, the company is responsible for solving all these bugs.
Because in software engineering, testing and maintenance are given, so there is
no worry of its reliability.
6. Effectiveness: Effectiveness comes if anything has made according to the
standards. Software standards are the big target of companies to make it more
effective. So Software becomes more effective in the act with the help of software
engineering.

Characteristics of Good Software – Software

Engineering
•
Software is treated as good software using different factors. A software
product is concluded as good software by what it offers and how well it can be
used. The factors that decide the software properties are divided into three
categories: Operational, Transitional, and Maintenance.

What is a Good Software?

Software engineering is the process of designing, developing, and maintaining
software systems. Good software meets the needs of its users, performs its
intended functions reliably, and is easy to maintain.
1. There are several characteristics of good software that are commonly
recognized by software engineers, which are important to consider when
developing a software system.
2. These characteristics include functionality, usability, reliability,
performance, security, maintainability, reusability, scalability, and
testability.

Software Characteristics

Categories of Software Characteristics

1. Operational
In operational categories, the factors that decide the software performance in operations.
It can be measured on:
• Budget
• Usability
• Efficiency
• Correctness
• Functionality
• Dependability
• Security
• Safety
2. Transitional
When the software is moved from one platform to another, the factors deciding the
software quality:
• Portability
• Interoperability
• Reusability
• Adaptability
3. Maintenance
In this categories all factors are included that describes about how well a software has the
capabilities to maintain itself in the ever changing environment:
• Modularity
• Maintainability
• Flexibility
• Scalability
Characterisitics of Good Software
1. Functionality: The software meets the requirements and specifications that it was
designed for, and it behaves as expected when it is used in its intended environment.
2. Usability: The software is easy to use and understand, and it provides a positive user
experience.
3. Reliability: The software is free of defects and it performs consistently and accurately
under different conditions and scenarios.
4. Performance: The software runs efficiently and quickly, and it can handle large
amounts of data or traffic.
5. Security: The software is protected against unauthorized access and it keeps the data
and functions safe from malicious attacks.
6. Maintainability: The software is easy to change and update, and it is well-
documented, so that it can be understood and modified by other developers.
7. Reusability: The software can be reused in other projects or applications, and it is
designed in a way that promotes code reuse.
8. Scalability: The software can handle an increasing workload and it can be easily
extended to meet the changing requirements.
9. Testability: The software is designed in a way that makes it easy to test and validate,
and it has a comprehensive test coverage.
By adhering to these characteristics, software engineers can develop software that is
functional, reliable, and maintainable, thus providing the best experience to the end-users.

Software Processes
The term software specifies to the set of computer programs, procedures and
associated documents (Flowcharts, manuals, etc.) that describe the program and how
they are to be used.

A software process is the set of activities and associated outcome that produce a
software product. Software engineers mostly carry out these activities. These are four
key process activities, which are common to all software processes. These activities are:

1. Software specifications: The functionality of the software and constraints on its

operation must be defined.
2. Software development: The software to meet the requirement must be
produced.
3. Software validation: The software must be validated to ensure that it does what
the customer wants.
 4. Software evolution: The software must evolve to meet changing client needs.

Software Development Life Cycle (SDLC)

A software life cycle model (also termed process model) is a pictorial and diagrammatic
representation of the software life cycle. A life cycle model represents all the methods
required to make a software product transit through its life cycle stages. It also captures
the structure in which these methods are to be undertaken.

In other words, a life cycle model maps the various activities performed on a software
product from its inception to retirement. Different life cycle models may plan the
necessary development activities to phases in different ways. Thus, no element which life
cycle model is followed, the essential activities are contained in all life cycle models
though the action may be carried out in distinct orders in different life cycle models.
During any life cycle stage, more than one activity may also be carried out.

Need of SDLC
The development team must determine a suitable life cycle model for a particular plan
and then observe to it.

Without using an exact life cycle model, the development of a software product would
not be in a systematic and disciplined manner. When a team is developing a software
product, there must be a clear understanding among team representative about when
and what to do. Otherwise, it would point to chaos and project failure. This problem can
be defined by using an example. Suppose a software development issue is divided into
various parts and the parts are assigned to the team members. From then on, suppose
the team representative is allowed the freedom to develop the roles assigned to them in
whatever way they like. It is possible that one representative might start writing the code
for his part, another might choose to prepare the test documents first, and some other
engineer might begin with the design phase of the roles assigned to him. This would be
one of the perfect methods for project failure.

A software life cycle model describes entry and exit criteria for each phase. A phase can
begin only if its stage-entry criteria have been fulfilled. So without a software life cycle
model, the entry and exit criteria for a stage cannot be recognized. Without software life
cycle models, it becomes tough for software project managers to monitor the progress
of the project.

SDLC Cycle
SDLC Cycle represents the process of developing software. SDLC framework includes the
following steps:

The stages of SDLC are as follows:

Stage1: Planning and requirement analysis

Requirement Analysis is the most important and necessary stage in SDLC.

The senior members of the team perform it with inputs from all the stakeholders and
domain experts or SMEs in the industry.

Planning for the quality assurance requirements and identifications of the risks
associated with the projects is also done at this stage.

Business analyst and Project organizer set up a meeting with the client to gather all the
data like what the customer wants to build, who will be the end user, what is the
objective of the product. Before creating a product, a core understanding or knowledge
of the product is very necessary.

For Example, A client wants to have an application which concerns money transactions.
In this method, the requirement has to be precise like what kind of operations will be
done, how it will be done, in which currency it will be done, etc.

Once the required function is done, an analysis is complete with auditing the feasibility
of the growth of a product. In case of any ambiguity, a signal is set up for further
discussion.

Once the requirement is understood, the SRS (Software Requirement Specification)

document is created. The developers should thoroughly follow this document and also
should be reviewed by the customer for future reference.

Stage2: Defining Requirements

Once the requirement analysis is done, the next stage is to certainly represent and
document the software requirements and get them accepted from the project
stakeholders.

This is accomplished through "SRS"- Software Requirement Specification document

which contains all the product requirements to be constructed and developed during
the project life cycle.

Stage3: Designing the Software

The next phase is about to bring down all the knowledge of requirements, analysis, and
design of the software project. This phase is the product of the last two, like inputs from
the customer and requirement gathering.

Stage4: Developing the project

In this phase of SDLC, the actual development begins, and the programming is built. The
implementation of design begins concerning writing code. Developers have to follow
the coding guidelines described by their management and programming tools like
compilers, interpreters, debuggers, etc. are used to develop and implement the code.

Stage5: Testing

After the code is generated, it is tested against the requirements to make sure that the
products are solving the needs addressed and gathered during the requirements stage.
During this stage, unit testing, integration testing, system testing, acceptance testing are
done.

Stage6: Deployment

Once the software is certified, and no bugs or errors are stated, then it is deployed.

Then based on the assessment, the software may be released as it is or with suggested
enhancement in the object segment.

After the software is deployed, then its maintenance begins.

Stage7: Maintenance

Once when the client starts using the developed systems, then the real issues come up
and requirements to be solved from time to time.

This procedure where the care is taken for the developed product is known as
maintenance.

SDLC Models
Software Development life cycle (SDLC) is a spiritual model used in project management
that defines the stages include in an information system development project, from an
initial feasibility study to the maintenance of the completed application.

There are different software development life cycle models specify and design, which are
followed during the software development phase. These models are also called
"Software Development Process Models." Each process model follows a series of
phase unique to its type to ensure success in the step of software development.

Here, are some important phases of SDLC life cycle:

Waterfall Model
The waterfall is a universally accepted SDLC model. In this method, the whole process of
software development is divided into various phases.

The waterfall model is a continuous software development model in which development

is seen as flowing steadily downwards (like a waterfall) through the steps of
requirements analysis, design, implementation, testing (validation), integration, and
maintenance.

Linear ordering of activities has some significant consequences. First, to identify the end
of a phase and the beginning of the next, some certification techniques have to be
employed at the end of each step. Some verification and validation usually do this mean
that will ensure that the output of the stage is consistent with its input (which is the
output of the previous step), and that the output of the stage is consistent with the
overall requirements of the system.
Prototype Model
The prototype model requires that before carrying out the development of actual
software, a working prototype of the system should be built. A prototype is a toy
implementation of the system. A prototype usually turns out to be a very crude version
of the actual system, possible exhibiting limited functional capabilities, low reliability,
and inefficient performance as compared to actual software. In many instances, the
client only has a general view of what is expected from the software product. In such a
scenario where there is an absence of detailed information regarding the input to the
system, the processing needs, and the output requirement, the prototyping model may
be employed.
Steps of Prototype Model

1. Requirement Gathering and Analyst

2. Quick Decision
3. Build a Prototype
4. Assessment or User Evaluation
5. Prototype Refinement
6. Engineer Product

Advantage of Prototype Model

1. Reduce the risk of incorrect user requirement

2. Good where requirement are changing/uncommitted
3. Regular visible process aids management
4. Support early product marketing
5. Reduce Maintenance cost.
6. Errors can be detected much earlier as the system is made side by side.

Disadvantage of Prototype Model

1. An unstable/badly implemented prototype often becomes the final product.

2. Require extensive customer collaboration
o Costs customer money
o Needs committed customer
o Difficult to finish if customer withdraw
o May be too customer specific, no broad market
3. Difficult to know how long the project will last.
4. Easy to fall back into the code and fix without proper requirement analysis,
design, customer evaluation, and feedback.
5. Prototyping tools are expensive.
6. Special tools & techniques are required to build a prototype.
7. It is a time-consuming process.
 Spiral Model – Software Engineering
•
The Spiral Model is one of the most important Software Development Life Cycle
models, which provides support for Risk Handling. This article focuses on discussing
the Spiral Model in detail.
What is the Spiral Model?
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 and analysis to
design, implementation, testing, and maintenance.
What Are the Phases of Spiral Model?
The Spiral Model is a risk-driven model, meaning that the focus is on managing risk
through multiple iterations of the software development process. It consists of the
following phases:
1. Planning
The first phase of the Spiral Model is the planning phase, where the scope of the project
is determined and a plan is created for the next iteration of the spiral.
0 seconds of 0 secondsVolume 0%

2. Risk Analysis
In the risk analysis phase, the risks associated with the project are identified and
evaluated.
3. Engineering
In the engineering phase, the software is developed based on the requirements gathered in
the previous iteration.
4. Evaluation
In the evaluation phase, the software is evaluated to determine if it meets the customer’s
requirements and if it is of high quality.
5. Planning
The next iteration of the spiral begins with a new planning phase, based on the results of
the evaluation.
The Spiral Model is often used for complex and large software development projects, as
it allows for a more flexible and adaptable approach to software development. It is also
well-suited to projects with significant uncertainty or high levels of risk.
The Radius of the spiral at any point represents the expenses(cost) of the project so far,
and the angular dimension represents the progress made so far in the current phase.

Each phase of the Spiral Model is divided into four quadrants as shown in the above
figure. The functions of these four quadrants are discussed below:
1. Objectives determination and identify alternative solutions: Requirements are
gathered from the customers and the objectives are identified, elaborated, and
analyzed at the start of every phase. Then alternative solutions possible for the phase
are proposed in this quadrant.
2. Identify and resolve Risks: During the second quadrant, all the possible solutions are
evaluated to select the best possible solution. Then the risks associated with that
solution are identified and the risks are resolved using the best possible strategy. At
the end of this quadrant, the Prototype is built for the best possible solution.
3. Develop the next version of the Product: During the third quadrant, the identified
features are developed and verified through testing. At the end of the third quadrant,
the next version of the software is available.
4. Review and plan for the next Phase: In the fourth quadrant, the Customers evaluate
the so-far developed version of the software. In the end, planning for the next phase is
started.
Risk Handling in Spiral Model
A risk is any adverse situation that might affect the successful completion of a software
project. The most important feature of the spiral model is handling these unknown risks
after the project has started. Such risk resolutions are easier done by developing a
prototype.
1. The spiral model supports coping with risks by providing the scope to build a
prototype at every phase of software development.
2. The Prototyping Model also supports risk handling, but the risks must be identified
completely before the start of the development work of the project.
3. But in real life, project risk may occur after the development work starts, in that case,
we cannot use the Prototyping Model.
4. In each phase of the Spiral Model, the features of the product dated and analyzed, and
the risks at that point in time are identified and are resolved through prototyping.
5. Thus, this model is much more flexible compared to other SDLC models.

Why Spiral Model is called Meta Model?

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.
1. The spiral model incorporates the stepwise approach of the Classical Waterfall Model.
2. 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.
3. 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.
4.
Advantages of the Spiral Model

Below are some advantages of the Spiral Model.

1. 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.
2. Good for large projects: It is recommended to use the Spiral Model in large and
complex projects.
3. Flexibility in Requirements: Change requests in the Requirements at a later phase
can be incorporated accurately by using this model.
4. 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.
5. 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.
6. 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.
7. Improved Communication: The Spiral Model provides for regular evaluations and
reviews, which can improve communication between the customer and the
development team.
8. Improved Quality: The Spiral Model allows for multiple iterations of the software
development process, which can result in improved software quality and reliability.
9.
Disadvantages of the Spiral Model

Below are some main disadvantages of the spiral model.

1. Complex: The Spiral Model is much more complex than other SDLC models.
2. Expensive: Spiral Model is not suitable for small projects as it is expensive.
3. 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.
4. Difficulty in time management: As the number of phases is unknown at the start of
the project, time estimation is very difficult.
5. Complexity: The Spiral Model can be complex, as it involves multiple iterations of
the software development process.
6. Time-Consuming: The Spiral Model can be time-consuming, as it requires multiple
evaluations and reviews.
7. Resource Intensive: The Spiral Model can be resource-intensive, as it requires a
significant investment in planning, risk analysis, and evaluations.
The most serious issue we face in the cascade model is that taking a long length to finish
the item, and the product became obsolete. To tackle this issue, we have another
methodology, which is known as the Winding model or spiral model. The winding model
is otherwise called the cyclic model.
 When To Use the Spiral Model?

1. When a project is vast in software engineering, a spiral model is utilized.

2. A spiral approach is utilized when frequent releases are necessary.
3. When it is appropriate to create a prototype
4. When evaluating risks and costs is crucial
5. The spiral approach is beneficial for projects with moderate to high risk.
6. The SDLC’s spiral model is helpful when requirements are complicated and
ambiguous.
7. If modifications are possible at any moment
8. When committing to a long-term project is impractical owing to shifting economic
priorities.

Evolutionary Model – Software Engineering

•

The evolutionary model is a combination of the Iterative and Incremental models of the
software development life cycle. Delivering your system in a big bang release, delivering
it in incremental process over time is the action done in this model. Some initial
requirements and architecture envisioning need to be done. It is better for software
products that have their feature sets redefined during development because of user
feedback and other factors. This article focuses on discussing the Evolutionary Model in
detail.
What is the Evolutionary Model?
The Evolutionary development model divides the development cycle into smaller,
incremental waterfall models in which users can get access to the product at the end of
each cycle.
1. Feedback is provided by the users on the product for the planning stage of the next
cycle and the development team responds, often by changing the product, plan, or
process.
2. Therefore, the software product evolves with time.
3. All the models have the disadvantage that the duration of time from the start of the
project to the delivery time of a solution is very high.
4. The evolutionary model solves this problem with a different approach.
5. The evolutionary model suggests breaking down work into smaller chunks,
prioritizing them, and then delivering those chunks to the customer one by one.
6. The number of chunks is huge and is the number of deliveries made to the customer.
7. The main advantage is that the customer’s confidence increases as he constantly gets
quantifiable goods or services from the beginning of the project to verify and validate
his requirements.
8. The model allows for changing requirements as well as all work is broken down into
maintainable work chunks.

Application of Evolutionary Model

1. It is used in large projects where you can easily find modules for incremental
implementation. Evolutionary model is commonly used when the customer wants to
start using the core features instead of waiting for the full software.
2. Evolutionary model is also used in object oriented software development because the
system can be easily portioned into units in terms of objects.
Necessary Conditions for Implementing this Model
1. Customer needs are clear and been explained in deep to the developer team.
2. There might be small changes required in separate parts but not a major change.
3. As it requires time, so there must be some time left for the market constraints.
4. Risk is high and continuous targets to achieve and report to customer repeatedly.
5. It is used when working on a technology is new and requires time to learn.
Advantages Evolutionary Model
1. Adaptability to Changing Requirements: Evolutionary models work effectively in
projects when the requirements are ambiguous or change often. They support
adjustments and flexibility along the course of development.
2. Early and Gradual Distribution: Functional components or prototypes can be
delivered early thanks to incremental development. Faster user satisfaction and
feedback may result from this.
3. User Commentary and Involvement: Evolutionary models place a strong emphasis
on ongoing user input and participation. This guarantees that the software offered
closely matches the needs and expectations of the user.
4. Improved Handling of Difficult Projects: Big, complex tasks can be effectively
managed with the help of evolutionary models. The development process is made
simpler by segmenting the project into smaller, easier-to-manage portions.
Disadvantages Evolutionary Model
1. Communication Difficulties: Evolutionary models require constant cooperation and
communication. The strategy may be less effective if there are gaps in communication
or if team members are spread out geographically.
2. Dependence on an Expert Group: A knowledgeable and experienced group that can
quickly adjust to changes is needed for evolutionary models. Teams lacking
experience may find it difficult to handle these model’s dynamic nature.
3. Increasing Management Complexity: Complexity can be introduced by organizing
and managing several increments or iterations, particularly in large projects. In order
to guarantee integration and synchronization, good project management is needed.
4. Greater Initial Expenditure: As evolutionary models necessitate continual testing,
user feedback and prototyping, they may come with a greater starting cost. This may
be a problem for projects that have limited funding.

RAD (Rapid Application Development) Model

RAD is a linear sequential software development process model that emphasizes a
concise development cycle using an element based construction approach. If the
requirements are well understood and described, and the project scope is a constraint,
the RAD process enables a development team to create a fully functional system within
a concise time period.

RAD (Rapid Application Development) is a concept that products can be developed

faster and of higher quality through:

o Gathering requirements using workshops or focus groups

o Prototyping and early, reiterative user testing of designs
o The re-use of software components
o A rigidly paced schedule that refers design improvements to the next product
version
 o Less formality in reviews and other team communication

The various phases of RAD are as follows:

1.Business Modelling: The information flow among business functions is defined by
answering questions like what data drives the business process, what data is generated,
who generates it, where does the information go, who process it and so on.

2. Data Modelling: The data collected from business modeling is refined into a set of
data objects (entities) that are needed to support the business. The attributes (character
of each entity) are identified, and the relation between these data objects (entities) is
defined.

3. Process Modelling: The information object defined in the data modeling phase are
transformed to achieve the data flow necessary to implement a business function.
Processing descriptions are created for adding, modifying, deleting, or retrieving a data
object.

4. Application Generation: Automated tools are used to facilitate construction of the

software; even they use the 4th GL techniques.
5. Testing & Turnover: Many of the programming components have already been
tested since RAD emphasis reuse. This reduces the overall testing time. But the new part
must be tested, and all interfaces must be fully exercised.

When to use RAD Model?

o When the system should need to create the project that modularizes in a short
span time (2-3 months).
o When the requirements are well-known.
o When the technical risk is limited.
o When there's a necessity to make a system, which modularized in 2-3 months of
period.
o It should be used only if the budget allows the use of automatic code generating
tools.

Advantage of RAD Model

o This model is flexible for change.
o In this model, changes are adoptable.
o Each phase in RAD brings highest priority functionality to the customer.
o It reduced development time.
o It increases the reusability of features.

Disadvantage of RAD Model

o It required highly skilled designers.
o All application is not compatible with RAD.
o For smaller projects, we cannot use the RAD model.
o On the high technical risk, it's not suitable.
o Required user involvement.
Agile Model
Agile methodology is a practice which promotes continues interaction of development
and testing during the SDLC process of any project. In the Agile method, the entire
project is divided into small incremental builds. All of these builds are provided in
iterations, and each iteration lasts from one to three weeks.

Any agile software phase is characterized in a manner that addresses several key
assumptions about the bulk of software projects:

1. It is difficult to think in advance which software requirements will persist and which will
change. It is equally difficult to predict how user priorities will change as the project
proceeds.
2. For many types of software, design and development are interleaved. That is, both
activities should be performed in tandem so that design models are proven as they are
created. It is difficult to think about how much design is necessary before construction is
used to test the configuration.
3. Analysis, design, development, and testing are not as predictable (from a planning point
of view) as we might like.

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.

When to use the Iterative Model?

1. When requirements are defined clearly and easy to understand.
2. When the software application is large.
3. When there is a requirement of changes in future.

Advantage(Pros) of Iterative Model:

1. Testing and debugging during smaller iteration is easy.
2. A Parallel development can plan.
3. It is easily acceptable to ever-changing needs of the project.
4. Risks are identified and resolved during iteration.
5. Limited time spent on documentation and extra time on designing.

Disadvantage(Cons) of Iterative Model:

1. It is not suitable for smaller projects.
2. More Resources may be required.
3. Design can be changed again and again because of imperfect requirements.
4. Requirement changes can cause over budget.
5. Project completion date not confirmed because of changing requirements.