Software Engineering (BCS601)

UNIT-1 INTRODUCTION
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.
 Software Engineering is the process of designing, developing, testing, and
maintaining software. It is a systematic and disciplined approach to
software development that aims to create high-quality, reliable, and
maintainable software.
1. Software engineering includes a variety of techniques, tools, and
methodologies, including requirements analysis, design, testing, and
maintenance.
2. It is a rapidly evolving field, and new tools and technologies are constantly
being developed to improve the software development process.
3. By following the principles of software engineering and using the
appropriate tools and methodologies, software developers can create high-
quality, reliable, and maintainable software that meets the needs of its
users.
4. Software Engineering is mainly used for large projects based on software
systems rather than single programs or applications.
 5. The main goal of Software Engineering is to develop software applications
for improving quality, budget, and time efficiency.
6. Software Engineering ensures that the software that has to be built should
be consistent, correct, also on budget, on time, and within the required
requirements.

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.

 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.
 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.
 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.
 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.
 Quality Management: Better procedure of software development provides
a better and quality software product.

Key Principles of Software Engineering

  Modularity: Breaking the software into smaller, reusable components that
can be developed and tested independently.
 Abstraction: Hiding the implementation details of a component and
exposing only the necessary functionality to other parts of the software.
 Encapsulation: Wrapping up the data and functions of an object into a
single unit, and protecting the internal state of an object from external
modifications.
 Reusability: Creating components that can be used in multiple projects,
which can save time and resources.
 Maintenance: Regularly updating and improving the software to fix bugs,
add new features, and address security vulnerabilities.
 Testing: Verifying that the software meets its requirements and is free of
bugs.
 Design Patterns: Solving recurring problems in software design by providing
templates for solving them.
 Agile methodologies: Using iterative and incremental development
processes that focus on customer satisfaction, rapid delivery, and flexibility.
 Continuous Integration & Deployment: Continuously integrating the code
changes and deploying them into the production environment.

Main Attributes of Software Engineering

Software Engineering is a systematic, disciplined, quantifiable study and approach
to the design, development, operation, and maintenance of a software system.
There are four main Attributes of Software Engineering.

 Efficiency: It provides a measure of the resource requirement of a software

product efficiently.
 Reliability: It assures that the product will deliver the same results when
used in similar working environment.
 Reusability: This attribute makes sure that the module can be used in
multiple applications.
  Maintainability: It is the ability of the software to be modified, repaired, or
enhanced easily with changing requirements.

Dual Role of Software

There is a dual role of software in the industry. The first one is as a product and
the other one is as a vehicle for delivering the product. We will discuss both of
them.

1. As a Product

 It delivers computing potential across networks of Hardware.

 It enables the Hardware to deliver the expected functionality.
 It acts as an information transformer because it produces, manages,
acquires, modifies, displays, or transmits information.

2. As a Vehicle for Delivering a Product

 It provides system functionality (e.g., payroll system).

 It controls other software (e.g., an operating system).
 It helps build other software (e.g., software tools).

Objectives of Software Engineering

 Maintainability: It should be feasible for the software to evolve to meet
changing requirements.
 Efficiency: The software should not make wasteful use of computing
devices such as memory, processor cycles, etc.
 Correctness: A software product is correct if the different requirements
specified in the SRS Document have been correctly implemented.
 Reusability: A software product has good reusability if the different
modules of the product can easily be reused to develop new products.
 Testability: Here software facilitates both the establishment of test criteria
and the evaluation of the software concerning those criteria.
  Reliability: It is an attribute of software quality. The extent to which a
program can be expected to perform its desired function, over an arbitrary
time period.
 Portability: In this case, the software can be transferred from one computer
system or environment to another.
 Adaptability: In this case, the software allows differing system constraints
and the user needs to be satisfied by making changes to the software.
 Interoperability: Capability of 2 or more functional units to process data
cooperatively.

Software components
In software engineering, software components refer to modular, self-contained
parts of a software system that can be independently developed, tested, and
reused. They are designed to perform specific functions and interact with other
components to form a complete system.

Here are the key types of software components:

1. Libraries/Frameworks:
Libraries are collections of pre-written code that developers can use to
perform common tasks, like handling input/output or working with
databases. A framework is a more extensive structure that provides a
foundation for building applications, often with predefined conventions
and tools.
2. Modules:
These are smaller, logical components of a software system that typically
handle a specific feature or functionality, such as user authentication or
data processing.
3. Services (in Service-Oriented Architecture - SOA):
Services are autonomous, self-contained components that communicate
with other services or clients over a network. Each service focuses on a
specific task (e.g., payment processing or data storage).
 4. Micro-services:
An architectural style where the software is composed of small,
independent services that work together. Each micro-service is responsible
for a specific business function and can be developed, deployed, and scaled
independently.
5. APIs (Application Programming Interfaces):
An API is an interface that allows different software components or
systems to communicate with one another. APIs define the methods and
data formats required for interaction between components or services.
6. Objects (in Object-Oriented Programming):
In object-oriented programming (OOP), components are often represented
as objects that encapsulate both data and the methods that operate on the
data. These objects interact with each other through method calls.
7. Database Components:
These include components like tables, stored procedures, views, and other
database objects that store and manage data within a software system.
8. User Interface (UI) Components:
These are components dedicated to presenting information to users and
accepting user inputs. Examples include buttons, forms, tables, and dialog
boxes.
9. Middleware:
Software that acts as a bridge between different applications or between
an application and a database, providing communication and data
management services.
10.External Systems:
Sometimes components are external to the core system but still part of the
overall architecture. These can include third-party services or external
libraries integrated into the system.

The goal of using components is to make software systems more maintainable,

scalable, and easier to modify, by reducing complexity through modularization
and promoting code reuse.
 What is Software Crisis?
Software Crisis is a term used in computer science for the difficulty of writing
useful and efficient computer programs in the required time. The software crisis
was due to using the same workforce, same methods, and same tools even
though rapidly increasing software demand, the complexity of software, and
software challenges. With the increase in software complexity, many software
problems arose because existing methods were insufficient.

Suppose we use the same workforce, same methods, and same tools after the
fast increase in software demand, software complexity, and software challenges.
In that case, there arise some issues like software budget problems, software
efficiency problems, software quality problems, software management, and
delivery problems, etc. This condition is called a Software Crisis.

Causes of Software Crisis

Following are the causes of Software Crisis:

Size: Software is becoming more expensive and more complex with the growing
complexity and expectation out of software. For example, the code in the
consumer product is doubling every couple of years.

Quality: Many software products have poor quality, i.e., the software products
defects after putting into use due to ineffective testing technique. For example,
Software testing typically finds 25 errors per 1000 lines of code.

Cost: Software development is costly i.e. in terms of time taken to develop and
the money involved. For example, Development of the FAA's Advanced
Automation System cost over $700 per lines of code.

Delayed Delivery: Serious schedule overruns are common. Very often the
software takes longer than the estimated time to develop, which in turn leads to
cost shooting up. For example, one in four large-scale development projects is
never completed.

Factor Contributing to Software Crisis are:

 Poor project management.

 Lack of adequate training in software engineering.
 Less skilled project members.
 Low productivity improvements.

Solution of Software Crisis:

There is no single solution to the crisis. One possible solution to a software crisis is
Software Engineering because software engineering is a systematic, disciplined,
and quantifiable approach. For preventing software crises, there are some
guidelines:

 Reduction in software over budget.

 The quality of the software must be high.
 Less time is needed for a software project.
 Experienced and skilled people working on the software project.
 Software must be delivered.
  Software must meet user requirements.

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.

The Software Process Model

A software process model is a specified definition of a software process, which is
presented from a particular perspective. Models, by their nature, are a
simplification, so a software process model is an abstraction of the actual process,
which is being described. Process models may contain activities, which are part of
the software process, software product, and the roles of people involved in
software engineering. Some examples of the types of software process models
that may be produced are:
 1. A workflow model: This shows the series of activities in the process along
with their inputs, outputs and dependencies. The activities in this model
perform human actions.
2. A dataflow or activity model: This represents the process as a set of
activities, each of which carries out some data transformations. It shows
how the input to the process, such as a specification is converted to an
output such as a design. The activities here may be at a lower level than
activities in a workflow model. They may perform transformations carried
out by people or by computers.
3. A role/action model: This means the roles of the people involved in the
software process and the activities for which they are responsible.

There are several various general models or paradigms of software development:

1. The waterfall approach: This takes the above activities and produces them
as separate process phases such as requirements specification, software
design, implementation, testing, and so on. After each stage is defined, it is
"signed off" and development goes onto the following stage.
2. Evolutionary development: This method interleaves the activities of
specification, development, and validation. An initial system is rapidly
developed from a very abstract specification.
3. Formal transformation: This method is based on producing a formal
mathematical system specification and transforming this specification,
using mathematical methods to a program. These transformations are
'correctness preserving.' This means that you can be sure that the
developed programs meet its specification.
4. System assembly from reusable components: This method assumes the
parts of the system already exist. The system development process target
on integrating these parts rather than developing them from scratch.
 Similarities Between Software Engineering Process and
Conventional Engineering Process
Software Engineering Process is an engineering process that is mainly related to
computers and programming and developing different kinds of applications
through the use of information technology.

Conventional Engineering Process is an engineering process that is highly based

on empirical knowledge and is about building cars, machines, and hardware. It is a
process that mainly involves science, mathematics, etc.

Conventional Engineering is related to computers, writing programs, and

implementing them.

 Both Software Engineering and Conventional Engineering Processes

become automated after some time.
 Both these processes are making our day-to-day place better.
 Both these processes have a fixed working time.
 Both processes must consist of deeper knowledge.

Difference Between Software Engineering Process and

Conventional Engineering Process

Software Engineering Conventional

Aspect
Process Engineering Process
Software Engineering The conventional
Process is a process Engineering Process is
Process that majorly involves a process that majorly
computer science, involves science,
information technology, mathematics, and
and discrete empirical knowledge.
 mathematics.
It is mainly related to It is about building
computers, cars, machines,
Focus Area programming, and hardware, buildings,
writing codes for etc.
building applications.
In Software In Conventional
Engineering Process Engineering Process
Cost construction and construction and
development costs are development cost is
low. high.
It can involve the It usually applies only
application of new and known and tested
Application
untested elements in principles to meet
software projects. product requirements
In the Software In Conventional
Engineering Process, Engineering Process,
most development most development
Development Effort
effort goes into building efforts are required to
new designs and change old designs.
features.
It majorly emphasizes It majorly emphasizes
Emphasis
quality. mass production.
Product development Product
develops intangible development
Product Nature products (software). develops tangible
products (e.g.
bridges, buildings).
Design requirements Design Requirements
may change are typically well-
Design Requirement
throughout the defined upfront.
development process.
Testing is an integral Testing occurs mainly
part of the after product
Testing completion
development
process
Prototyping is common Prototyping is less
Prototyping
and helps to refine common due to cost
 requirements. and time.
Maintenance and Maintenance is
updates are necessary typically scheduled or
Maintenance
to keep software reactive.
relevant.
Software development Conventional
often involves complex engineering may have
Complexity
logic and algorithms. more complex physical
properties to deal with.
Software development Conventional
often follows engineering may have
Framework established standards well-established
and frameworks. regulations and
standards.
Software development Conventional
is typically less engineering may be
expensive to start, but more expensive to
Cost Dynamics costs may increase start due to materials
with maintenance and and construction but
updates may have lower
maintenance costs.
Agile methodologies Conventional
are commonly used in engineering may use
Methodologies software development. more traditional project
management
approaches.
 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.

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
Winston Royce introduced the Waterfall Model in 1970.This model has five
phases: Requirements analysis and specification, design, implementation, and
unit testing, integration and system testing, and operation and maintenance. The
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 cascade
of waterfalls.

1. Requirements analysis and specification phase: 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 so as to
document all the functions, performance, and interfacing requirement of the
software. It describes the "what" of the system to be produced and not "how."In
this phase, a large document called Software Requirement Specification (SRS)
document is created which contained a detailed description of what the system
will do in the common language.

2. Design Phase: This phase aims to transform the requirements gathered in the
SRS into a suitable form which permits further coding in a programming language.
It defines the overall software architecture together with high level and detailed
design. All this work is documented as a Software Design Document (SDD).

3. Implementation and unit testing: During this phase, design is implemented. If

the SDD is complete, the implementation or coding phase proceeds smoothly,
because all the information needed by software developers is contained in the
SDD. During testing, the code is thoroughly examined and modified. Small
modules are tested in isolation initially. After that these modules are tested by
writing some overhead code to check the interaction between these modules and
the flow of intermediate output.
4. Integration and System Testing: This phase is highly crucial 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. Unit testing determines the efficiency of individual modules.
However, in this phase, the modules are tested for their interactions with each
other and with the system.

5. Operation and maintenance phase: Maintenance is the task performed by

every user once the software has been delivered to the customer, installed, and
operational.

When to use SDLC Waterfall Model?

Some Circumstances where the use of the Waterfall model is most suited are:

 When the requirements are constant and not changed regularly.

 A project is short
 The situation is calm
 Where the tools and technology used is consistent and is not changing
 When resources are well prepared and are available to use.

Advantages of Waterfall model

 This model is simple to implement also the number of resources that are
required for it is minimal.
 The requirements are simple and explicitly declared; they remain
unchanged during the entire project development.
 The start and end points for each phase is fixed, which makes it easy to
cover progress.
 The release date for the complete product, as well as its final cost, can be
determined before development.
 It gives easy to control and clarity for the customer due to a strict reporting
system.

Disadvantages of Waterfall model

  In this model, the risk factor is higher, so this model is not suitable for more
significant and complex projects.
 This model cannot accept the changes in requirements during
development.
 It becomes tough to go back to the phase. For example, if the application
has now shifted to the coding phase, and there is a change in requirement,
It becomes tough to go back and change it.
 Since the testing done at a later stage, it does not allow identifying the
challenges and risks in the earlier phase, so the risk reduction strategy is
difficult to prepare.

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

 Requirement Gathering and Analyst

 Quick Decision
 Build a Prototype
 Assessment or User Evaluation
 Prototype Refinement
 Engineer Product

Advantage of Prototype Model

 Reduce the risk of incorrect user requirement

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

Disadvantage of Prototype Model

 An unstable/badly implemented prototype often becomes the final

product.
 Require extensive customer collaboration
 Costs customer money
 Needs committed customer
 Difficult to finish if customer withdraw
 May be too customer specific, no broad market
 Difficult to know how long the project will last.
 Easy to fall back into the code and fix without proper requirement analysis,
design, customer evaluation, and feedback.
 Prototyping tools are expensive.
 Special tools & techniques are required to build a prototype.
 It is a time-consuming process.

Spiral Model
The spiral model, initially proposed by Boehm, is an evolutionary software process
model that couples the iterative feature of prototyping with the controlled and
systematic aspects of the linear sequential model. It implements the potential for
rapid development of new versions of the software. Using the spiral model, the
software is developed in a series of incremental releases. During the early
iterations, the additional release may be a paper model or prototype. During later
iterations, more and more complete versions of the engineered system are
produced.
Each cycle in the spiral is divided into four parts:

Objective setting: Each cycle in the spiral starts with the identification of purpose
for that cycle, the various alternatives that are possible for achieving the targets,
and the constraints that exists.

Risk Assessment and reduction: The next phase in the cycle is to calculate these
various alternatives based on the goals and constraints. The focus of evaluation in
this stage is located on the risk perception for the project.

Development and validation: The next phase is to develop strategies that resolve
uncertainties and risks. This process may include activities such as benchmarking,
simulation, and prototyping.
Planning: Finally, the next step is planned. The project is reviewed, and a choice
made whether to continue with a further period of the spiral. If it is determined
to keep, plans are drawn up for the next step of the project.

The development phase depends on the remaining risks. For example, if

performance or user-interface risks are treated more essential than the program
development risks, the next phase may be an evolutionary development that
includes developing a more detailed prototype for solving the risks.

The risk-driven feature of the spiral model allows it to accommodate any mixture
of a specification-oriented, prototype-oriented, simulation-oriented, or another
type of approach. An essential element of the model is that each period of the
spiral is completed by a review that includes all the products developed during
that cycle, including plans for the next cycle. The spiral model works for
development as well as enhancement projects.

When to use Spiral Model?

 When deliverance is required to be frequent.

 When the project is large
 When requirements are unclear and complex
 When changes may require at any time
 Large and high budget projects

Advantages

 High amount of risk analysis

 Useful for large and mission-critical projects.

Disadvantages

 Can be a costly model to use.

 Risk analysis needed highly particular expertise
 Doesn't work well for smaller projects.
 Evolutionary Process Model
The evolutionary model is based on the concept of making an initial product and
then evolving the software product over time with iterative and incremental
approaches with proper feedback. In this type of model, the product will go
through several iterations and come up when the final product is built through
multiple iterations. The development is carried out simultaneously with the
feedback during the development. This model has a number of advantages such
as customer involvement, taking feedback from the customer during
development, and building the exact product that the user wants. Because of the
multiple iterations, the chances of errors get reduced and the reliability and
efficiency will increase.

Types of Evolutionary Process Models

 Iterative Model
 Incremental Model
 Spiral Model

Iterative Model

In the iterative model first, we take the initial requirements then we enhance the
product over multiple iterations until the final product gets ready. In every
iteration, some design modifications were made and some changes in functional
requirements is added. The main idea behind this approach is to build the final
product through multiple iterations that result in the final product being almost
the same as the user wants with fewer errors and the performance, and quality
would be high.
Incremental Model

In the incremental model, we first build the project with basic features and then
evolve the project in every iteration, it is mainly used for large projects. The first
step is to gather the requirements and then perform analysis, design, code, and
test and this process goes the same over and over again until our final project is
ready.

Spiral Model

The spiral model is a combination of waterfall and iterative models and in this, we
focused on risk handling along with developing the project with the incremental
and iterative approach, producing the output quickly as well as it is good for big
projects. The software is created through multiple iterations using a spiral
approach. Later on, after successive development the final product will develop,
and the customer interaction is there so the chances of error get reduced.
Advantages of the Evolutionary Process Model

 During the development phase, the customer gives feedback regularly

because the customer’s requirement gets clearly specified.
 After every iteration risk gets analyzed.
 Suitable for big complex projects.
 The first build gets delivered quickly as it used an iterative and incremental
approach.
 Enhanced Flexibility: The iterative nature of the model allows for
continuous changes and refinements to be made, accommodating changing
requirements effectively.
 Risk Reduction: The model’s emphasis on risk analysis during each iteration
helps in identifying and mitigating potential issues early in the development
process.
 Adaptable to Changes: Since changes can be incorporated at the beginning
of each iteration, it is well-suited for projects with evolving or uncertain
requirements.
 Customer Collaboration: Regular customer feedback throughout the
development process ensures that the end product aligns more closely with
the customer’s needs and expectations.

Disadvantages of the Evolutionary Process Model

  It is not suitable for small projects.
 The complexity of the spiral model can be more than the other sequential
models.
 The cost of developing a product through a spiral model is high.
 Project Management Complexity: The iterative nature of the model can
make project management and tracking more complex compared to linear
models.
 Resource Intensive: The need for continuous iteration and customer
feedback demands a higher level of resources, including time, personnel,
and tools.
 Documentation Challenges: Frequent changes and iterations can lead to
challenges in maintaining accurate and up-to-date documentation.
 Potential Scope Creep: The flexibility to accommodate changes can
sometimes lead to an uncontrolled expansion of project scope, resulting in
scope creep.
 Initial Planning Overhead: The model’s complexity requires a well-defined
initial plan, and any deviations or adjustments can be time-consuming and
costly.

Iterative Enhancement Model

In software development, the Iterative Enhancement Model stands out due to its
incremental and iterative nature, it is also known as an incremental model. This
approach focuses on incremental development and improvement rather than
trying to complete a software product in a single phase. This model is based on
segmenting the project into smaller units, or iterations, with a set of tasks
completed.

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?

 When requirements are defined clearly and easy to understand.

 When the software application is large.
 When there is a requirement of changes in future.

Advantage(Pros) of Iterative Model:

 Testing and debugging during smaller iteration is easy.

 A Parallel development can plan.
 It is easily acceptable to ever-changing needs of the project.
 Risks are identified and resolved during iteration.
 Limited time spent on documentation and extra time on designing.

Disadvantage(Cons) of Iterative Model:

 It is not suitable for smaller projects.

  More Resources may be required.
 Design can be changed again and again because of imperfect requirements.
 Requirement changes can cause over budget.
 Project completion date not confirmed because of changing requirements.

What is the Iterative Enhancement Model?

Software development uses a dynamic and adaptable method called the iterative
enhancement Model. The iterative enhancement model encourages a software
product's ongoing evolution and improvement. This methodology is noticeable
due to its concentration on adaptability, flexibility and change responsiveness. It
makes it easier for a product to evolve because it gives developers the freedom to
progressively enhance the software, making sure that it complies with evolving
specifications, user demands, and market demands. This helps products evolve
more easily.

The Iterative Enhancement Model creates an environment where development

teams can more effectively adjust to changing requirements by segmenting the
software development process into smaller, more manageable parts. Every
iteration improves on the one before it, adding new features and fixing problems
found in earlier stages. Members of the team, stakeholders and end users are
encouraged to collaborate and communicate continuously to make sure the
software meets changing needs and expectations. Until the software is finished
being built, the iteration process is carried out, which involves giving the user the
increments.

Advantages of Iterative Enhancement Model

 Adaptation to changing requirements is made possible by its flexibility in

accomodating modifications and improvement during each iteration.
 Early software iterations provide clients with functional portions of the
product, facilitating prompt feedback and validation.
 Problems and risks can be identified and addressed early in the
development process, reduces chances of issue for future stages.
 Feedback and constant client involvement are encouraged to make sure
the finished product lives up to user expectations.
 Every iteration is put through testing and improvement, leading to higher
quality product.

Disadvantages of Iterative Enhancement Model

 Especially in larger projects, managing several iterations at once can add

complexity.
 Higher cost
 Due to constant changes, there may be delays in documentation, making it
more difficult to maintain comprehensive documentation.
 Continuous customer engagement may not be possible in all scenarios,
which impacts the effectiveness of the model.

Specific use cases where this model proves beneficial include:

 Mobile app development: Updates and improvements are often needed for
mobile apps to stay current with new devices, operating system versions
and user preferences. By using an iterative process developers can release
 the beta versions of their apps, get user feedback and then improve
functionality of those iterations in future release.
 Web Application Development: The requirements for developing web
applications frequently change as a result of shifting user demand and
advancements in technology. The Iterative Enhancement Model makes it
possible to developed features incrementally and guaranteeing that the
application can be modified to satisfy changing user and market demands.
In later iterations it also makes it easier to incorporate new features based
on input from users.
 E-commerce Platforms: Development in e-commerce field often involves
constant updates. Implementing an iterative approach enables the
introduction of new functionality.