UNIT 1

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.
Characteristics of a good software engineer
The features that good software engineers should possess are
as follows:
Exposure to systematic methods, i.e., familiarity with software engineering
principles.

Good technical knowledge of the project range (Domain knowledge).

Good programming abilities.

Good communication skills. These skills comprise of oral, written, and

interpersonal skills.

High motivation.

Sound knowledge of fundamentals of computer science.

Intelligence.

Ability to work in a team

Discipline, etc.

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.

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.

Components of Software :
There are three components of the software: These are : Program,
Documentation, and Operating Procedures.
1. Program –
A computer program is a list of instructions that tell a computer what
to do.

2. Documentation –
Source information about the product contained in design
documents, detailed code comments, etc.

3. Operating Procedures –
Set of step-by-step instructions compiled by an organization to
help workers carry out complex routine operations.
4. Code: the instructions that a computer executes in order to
perform a specific task or set of tasks.
5. Data: the information that the software uses or manipulates.
6. User interface: the means by which the user interacts with the
software, such as buttons, menus, and text fields.
 7. Libraries: pre-written code that can be reused by the software to
perform common tasks.
8. Documentation: information that explains how to use and
maintain the software, such as user manuals and technical guides.
9. Test cases: a set of inputs, execution conditions, and expected
outputs that are used to test the software for correctness and
reliability.
10. Configuration files: files that contain settings and parameters
that are used to configure the software to run in a specific
environment.
11. Build and deployment scripts: scripts or tools that are used to
build, package, and deploy the software to different environments.
12. Metadata: information about the software, such as version
numbers, authors, and copyright information.
Software Characteristics – Software
Engineering
The characteristics of the software include:
• It is intangible, meaning it cannot be seen or touched.
• It is non-perishable, meaning it does not degrade over time.
• It is easy to replicate, meaning it can be copied and distributed
easily.
• It can be complex, meaning it can have many interrelated parts and
features.
• It can be difficult to understand and modify, especially for large
and complex systems.
• It can be affected by changing requirements, meaning it may need
to be updated or modified as the needs of users change.
• It can be impacted by bugs and other issues, meaning it may need
to be tested and debugged to ensure it works as intended.
Components of Software Characteristics:
There are basically 6 components of Software Characteristics that are
discussed here. We will discuss each one of them in detail.
Functionality:
It refers to the degree of performance of the software against its intended
purpose.
Functionality refers to the set of features and capabilities that a software
program or system provides to its users. It is one of the most important
characteristics of software, as it determines the usefulness of the software
for the intended purpose. Examples of functionality in software include:
• Data storage and retrieval
• Data processing and manipulation
• User interface and navigation
• Communication and networking
• Security and access control
• Reporting and visualization
• Automation and scripting
The more functionality a software has, the more powerful and versatile it is,
but also the more complex it can be. It is important to balance the need for
functionality with the need for ease of use, maintainability, and scalability.
Reliability:
A set of attributes that bears on the capability of software to maintain its
level of performance under the given condition for a stated period of time.
Reliability is a characteristic of software that refers to its ability to perform its
intended functions correctly and consistently over time. Reliability is an
important aspect of software quality, as it helps ensure that the software will
work correctly and not fail unexpectedly.
Examples of factors that can affect the reliability of software include:
1. Bugs and errors in the code
2. Lack of testing and validation
3. Poorly designed algorithms and data structures
4. Inadequate error handling and recovery
5. Incompatibilities with other software or hardware
To improve the reliability of software, various techniques, and methodologies
can be used, such as testing and validation, formal verification, and fault
tolerance.
Software is considered reliable when the probability of it failing is low and it
is able to recover from the failure quickly, if any.
Efficiency:
It refers to the ability of the software to use system resources in the most
effective and efficient manner. The software should make effective use of
storage space and executive command as per desired timing requirements.
Efficiency is a characteristic of software that refers to its ability to use
resources such as memory, processing power, and network bandwidth in an
optimal way. High efficiency means that a software program can perform its
intended functions quickly and with minimal use of resources, while low
efficiency means that a software program may be slow or consume excessive
resources.
Examples of factors that can affect the efficiency of the software include:
1. Poorly designed algorithms and data structures
2. Inefficient use of memory and processing power
3. High network latency or bandwidth usage
4. Unnecessary processing or computation
5. Unoptimized code
To improve the efficiency of software, various techniques, and methodologies
can be used, such as performance analysis, optimization, and profiling.
Efficiency is important in software systems that are resource-constrained,
high-performance, and real-time systems. It is also important in systems that
need to handle many users or transactions simultaneously.
Usability:
It refers to the extent to which the software can be used with ease. the
amount of effort or time required to learn how to use the software.

Maintainability:
It refers to the ease with which modifications can be made in a software
system to extend its functionality, improve its performance, or correct errors.
Portability:
A set of attributes that bears on the ability of software to be transferred from
one environment to another, without minimum changes.

#Software Crisis :
1. Size and Cost –
Day to day growing complexity and expectation out of software.
Software are more expensive and more complex.

2. Quality –
Software products must have good quality.

3. Delayed Delivery –
Software takes longer than the estimated time to develop, which
in turn leads to cost shooting up.
4. The term “software crisis” refers to a set of problems that were
faced by the software industry in the 1960s and 1970s, such as:
5. High costs and long development times: software projects were
taking much longer and costing much more than expected.
6. Low quality: software was often delivered late, with bugs and
other defects that made it difficult to use.
7. Lack of standardization: there were no established best practices
or standards for software development, making it difficult to
compare and improve different approaches.
8. Lack of tools and methodologies: there were few tools and
methodologies available to help with software development,
making it a difficult and time-consuming process.
9. These problems led to a growing realization that the traditional
approaches to software development were not effective and
needed to be improved. This led to the development of new
software development methodologies, such as the Waterfall and
 Agile methodologies, as well as the creation of new tools and
technologies to support software development.

Software Processes in Software Engineering

• Waterfall: a linear, sequential approach to software development,
with distinct phases such as requirements gathering, design,
implementation, testing, and maintenance.
• Agile: a flexible, iterative approach to software development, with
an emphasis on rapid prototyping and continuous delivery.
• Scrum: a popular Agile methodology that emphasizes teamwork,
iterative development, and a flexible, adaptive approach to
planning and management.
• DevOps: a set of practices that aims to improve collaboration and
communication between development and operations teams, with
an emphasis on automating the software delivery process.

Similarity and Differences from Conventional Engineering

Processes
Similarities:

Both are getting automated slowly.

•
• Both require in-depth knowledge of their field.
• Both have fixed work timings most of the time unlike
doctors.
• Both are trying to make the world a better place.
Differences:

• Software Engineers have a high starting salary.

• Conventional engineers have higher government sector
opportunity.
• Software Engineers have more opportunities of foreign
settlement.
• Software Engineer have a typical office job whereas
conventional ones have a more physically active role.

Software Quality Attributes

Software quality product is defined in term of its fitness of purpose. That is, a
quality product does precisely what the users want it to do. For software
products, the fitness of use is generally explained in terms of satisfaction of the
requirements laid down in the SRS document. Although "fitness of purpose" is a
satisfactory interpretation of quality for many devices such as a car, a table fan, a
grinding machine, etc.for software products, "fitness of purpose" is not a wholly
satisfactory definition of quality.
Quality attributes and characteristics are extremely important in the design of
software systems in general.
The quality of the product contributes to improved user requirements &
satisfaction, clearer software design, and ultimately greater end product quality.
These Software Quality Attributes in software engineering can be
categorized under specific areas as mentioned below:
#1) Design and Software Architecture Quality Attributes
• Conceptual Integrity
• Maintainability
• Reusability
• Correctness
#2) Runtime Qualities
• Reliability
• Interoperability
• Scalability (Flexibility)
• Performance
• Security
• Availability
#3) System Qualities
• Supportability
• Testability
#4) User Qualities
• Usability
#5) Non-runtime Qualities
• Portability
• Reusability

1) Reliability
Synonym for reliability is assurance. Reliability can be defined as the degree to
which a software system or its components or a service performs specific
functions under predefined conditions for a set period. It is the likelihood of
fault-free software operation for a specified period of time in a specified
environment.
It is the measure of the ability of a software application or service to
consistently maintain operations in a predefined condition. It is critical to verify
that the software is fully functional, especially when under maximum load.

2) Maintainability
It is the ease with which a software developer is able to fix flaws in the existing
functionality without impacting other components of the software system. It
also considers the ease with which a developer can add new features, update
existing features or upgrade the system with new technology.

Software maintainability is achieved through adherence to software

architectural rules and consistency across the application.

The purpose of having this attribute is to make the maintenance of software

applications easy and cost-effective.

3) Usability
This attribute refers to the quality of the end user’s experience while interacting
with the application or service. Usability is concerned with effectiveness,
efficiency, and overall user satisfaction.

This attribute helps to measure the ease of use of any software application or
service (e.g., registering a new account and then signing in to the account)

4) Portability
It refers to the extent to which a system or its components can be migrated
(transported) to other environments consisting of different hardware and/or
different software (operating system). The importance of software
portability should not be underestimated.

5) Correctness
This refers to the ability of software products or services to perform tasks (e.g.
calculations, sign-ups, navigations) correctly as specified by the predefined
requirements when used under specified conditions.

It is a measure of whether a software system is correct or not, implying that it is

an all-or-nothing attribute.
6) Efficiency
It is one of the most important software quality attributes. It reveals the
performance of a software product concerning the number of resources utilized
under predefined conditions. It is measured simply in terms of the time
required by the software system or service to complete any given task.

Software application performance management is thus critical to any

organization.
A software application can be said as inefficient from the user’s perspective
when it utilizes too many resources of the system (machine) that slow down
other applications or the entire machine.

7) Security
It is defined as the capacity of a system to fend off or thwart malicious or
unauthorized attempts to intrude and damage it while still allowing access to
authorized users. Additionally, it also measures the ability of the software
system to safeguard data and information from unauthorized entities.

As in recent years, the number of cyber-attacks are on the rise, security of a

software system should be given very high priority.

It also consists of authorization and authentication techniques, safeguarding

against network attacks, sending encrypted data wherever necessary, prevent
SQL injection.

8) Testability
It defines the ease with which QA and other beta users can test the software
application and detect bugs. It also evaluates the ease with which the testing
personnel can design test criteria for the application and its various
components.

Another criterion could be the number of test cases or features that can be
automated so that the testing process itself can be automated.

In simple terms, testability identifies how fast a system can be tested to ensure
quality against predefined specifications.
9) Flexibility (Modifiability)
It is the degree to which software applications can adapt to future changes
(e.g., upcoming technologies, market trends, business rules, regulations, etc.)

A software application can be called flexible if it can run smoothly on any type
of device, hardware platform, and/or operating system. It should be easy to
interface with any other software products, third-party software, or libraries.

The ability to create new business opportunities is a clear advantage of flexible

software. You can gain a competitive advantage in your functional area and thus
drive more customers by enhancing your existing software with new features
and integrations.

10) Scalability
This attribute relates to the software system’s capability to handle the
increased load (usage) without degrading its performance. The industry (the
software industry in particular) should always consider the importance of
software scalability.

11) Compatibility
It refers to the ability of the application to integrate seamlessly with other
software applications under prescribed conditions and perform its actions
efficiently while sharing the same hardware and software (e.g. Operating
system). The app should be able to work as expected on different devices,
hardware, and software platforms.

It also considers the ability of software applications (in this case web
applications) to work correctly on different types of browsers and their several
versions.

Along with forward compatibility (compatibility with newer versions), it is

important to consider backward compatibility as well (e.g. ensuring that web
applications work on now-defunct IE).

Software Development Life Cycle (SDLC) Models:

Software development life cycle (SDLC) is a structured process that is
used to design, develop, and test good-quality software. SDLC, or software
development life cycle, is a methodology that defines the entire procedure of
software development step-by-step.

SDLC is a process followed for software building within a software

organization. SDLC consists of a precise plan that describes how to
develop, maintain, replace, and enhance specific software. The life
cycle defines a method for improving the quality of software and the
all-around development process.

Stages of the Software Development Life Cycle

Stage-1: Planning and Requirement Analysis
Planning is a crucial step in everything, just as in software development. In this
same stage, requirement analysis is also performed by the developers of the
organization. This is attained from customer inputs, and sales
department/market surveys.
The information from this analysis forms the building blocks of a basic project.
The quality of the project is a result of planning. Thus, in this stage, the basic
project is designed with all the available information.

Stage-2: Defining Requirements

In this stage, all the requirements for the target software are specified. These
requirements get approval from customers, market analysts, and stakeholders.
This is fulfilled by utilizing SRS (Software Requirement Specification). This is a
sort of document that specifies all those things that need to be defined and
created during the entire project cycle.

Stage-3: Designing Architecture

SRS is a reference for software designers to come up with the best architecture
for the software. Hence, with the requirements defined in SRS, multiple designs
for the product architecture are present in the Design Document Specification
(DDS).
This DDS is assessed by market analysts and stakeholders. After evaluating all
the possible factors, the most practical and logical design is chosen for
development.

Stage-4: Developing Product

At this stage, the fundamental development of the product starts. For this,
developers use a specific programming code as per the design in the DDS.
Hence, it is important for the coders to follow the protocols set by the
association. Conventional programming tools like compilers, interpreters,
debuggers, etc. are also put into use at this stage. Some popular languages like
C/C++, Python, Java, etc. are put into use as per the software regulations.

Stage-5: Product Testing and Integration

After the development of the product, testing of the software is necessary to
ensure its smooth execution. Although, minimal testing is conducted at every
stage of SDLC. Therefore, at this stage, all the probable flaws are tracked, fixed,
and retested. This ensures that the product confronts the quality requirements
of SRS.
Documentation, Training, and Support: Software documentation is an
essential part of the software development life cycle. A well-written document
acts as a tool and means to information repository necessary to know about
software processes, functions, and maintenance. Documentation also provides
information about how to use the product. Training in an attempt to improve
the current or future employee performance by increasing an employee’s
ability to work through learning, usually by changing his attitude and
developing his skills and understanding.

Stage 6: Deployment and Maintenance of Products

After detailed testing, the conclusive product is released in phases as per the
organization’s strategy. Then it is tested in a real industrial environment. It is
important to ensure its smooth performance. If it performs well, the
organization sends out the product as a whole. After retrieving beneficial
feedback, the company releases it as it is or with auxiliary improvements to
make it further helpful for the customers. However, this alone is not enough.
Therefore, along with the deployment, the product’s supervision.

Software Development Life Cycle Models

To this day, we have more than 50 recognized SDLC models in use. But None
of them is perfect, and each brings its favourable aspects and disadvantages
for a specific software development project or a team.
In this article, We’ve listed the top five most popular SDLC models below.

1. Waterfall Model
It is the fundamental model of the software development life cycle. This is a
very simple model. The waterfall model is not in practice anymore, but it is the
basis for all other SDLC models. Because of its simple structure, the waterfall
model is easier to use and provides a tangible output. In the waterfall model,
once a phase seems to be completed, it cannot be changed, and due to this
less flexible nature, the waterfall model is not in practice anymore

2. Agile Model
The agile model was mainly designed to adapt to changing requests quickly.
The main goal of the Agile model is to facilitate quick project completion. The
agile model refers to a group of development processes. These processes have
some similar characteristics but also possess certain subtle differences among
themselves.

3. Iterative Model
In the iterative model, each cycle results in a semi-developed but deployable
version; with each cycle, some requirements are added to the software, and
the final cycle results in the software with the complete requirement
specification.
4. Spiral Model
The spiral model is one of the most crucial SDLC models that provides support
for risk handling. It has various spirals in its diagrammatic representation; the
number of spirals depends upon the type of project. Each loop in the spiral
structure indicates the Phases of the Spiral model.

5.V-Shaped Model
The V-shaped model is executed in a sequential manner in V-shape. Each stage
or phase of this model is integrated with a testing phase. After every
development phase, a testing phase is associated with it, and the next phase
will start once the previous phase is completed, i.e., development & testing. It
is also known as the verification or validation model.

6. Big Bang Model

The Big Bang model in SDLC is a term used to describe an informal and
unstructured approach to software development, where there is no specific
planning, documentation, or well-defined phases

What is the need for SDLC?

SDLC is a method, approach, or process that is followed by a software
development organization while developing any software. SDLC models were
introduced to follow a disciplined and systematic method while designing
software. With the software development life cycle, the process of software
design is divided into small parts, which makes the problem more
understandable and easier to solve. SDLC comprises a detailed description or
step-by-step plan for designing, developing, testing, and maintaining the
software.

Water Fall 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.

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:

o When the requirements are constant and not changed regularly.

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

Advantages of Waterfall model

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

Disadvantages of Waterfall model

o In this model, the risk factor is higher, so this model is not suitable for more
significant and complex projects.
o This model cannot accept the changes in requirements during
development.
o 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.
o 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

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
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.

The Spiral Model is shown in fig:

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?

o When deliverance is required to be frequent.

 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

Advantages

o High amount of risk analysis

o Useful for large and mission-critical projects.

Disadvantages

o Can be a costly model to use.

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

Evolutionary Development Models

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.

Iterative Enhancement Models

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.