UNIT-1

1. Introduction: Introduction to Software Engineering

2. Software Components
3. Software Characteristics
4. Software Crisis
5. Software Engineering Processes
6. Similarity and Differences from Conventional Engineering
Processes
7. Software Quality Attributes.
8. Software Development Life Cycle (SDLC) Models:
❑ Water Fall Model
❑ Prototype Model
❑ Spiral Model
❑ Evolutionary Development Models
❑ Iterative Enhancement Models.
 1. Introduction to Software Engineering
The term software engineering is the product of two words, software
and engineering.
SOFTWARE:
In the most general sense, software is a set of instructions that tell a computer
what to do. These instructions can be anything from a simple game to a
complex operating system. We can divide software types into two categories:
system software and application software.
Definition: Software is a set of programs, data, or instructions that enable a
computer to perform tasks.
Types of Software:
1. System Software – Manages hardware & system operations.
Example: Operating Systems (Windows, Linux).
2. Application Software – Designed for user tasks.
Example: Web Browsers, MS Office.
3. Programming Software – Used to develop software.
Example: Compilers, IDEs.

ENGINEERING:
Engineering is the application of scientific and practical knowledge to invent,
design, build, maintain, and improve frameworks, processes, etc.
 SOFTWARE ENGINEERING
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.

2. S O F T W A R E C O M PO N E NTS
Components in software are like building blocks that make up a program. Each
component has a specific job and works together with other components to
create a complete system.

Program

Operating
Documentation Procedures
• Program (Code) – The actual set of instructions written in a programming
language that executes tasks.
Example: A web application’s backend code.
• Documentation – Manuals, guides, and code comments that explain the
software’s functionality and usage.
Example: API documentation for developers.
• Operating Procedures – Guidelines for installing, running, and
maintaining the software.
Example: IT policies for software updates.

Characteristics of Software Components

• Modularity – Each component is a self-contained unit.
• Reusability – Components can be reused in different applications.
•Replaceability – Components can be replaced with minimal impact on the
system.
• Interoperability – Components can interact with other software elements.
• Encapsulation – Internal implementation details are hidden from the rest of
the system.

3. Characteristics of the Software

Software characteristics define the qualities that make software reliable,
efficient, and maintainable. These characteristics help in assessing the quality
of a software system and its effectiveness in solving user problems.
Functionality: Functionality refers to the set of features and capabilities that a
software program or system provides to its users.
Reliability:
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.
Efficiency:
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.
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.
Characteristics of “Software” in Software Engineering
1. Software is developed or engineered; it is not manufactured in the
classical sense:
•Although some similarities exist between software development and
hardware manufacturing, few activities are fundamentally different.
•In both activities, high quality is achieved through good design, but the
manufacturing phase for hardware can introduce quality problems than
software.
2. The software doesn’t “wear out.”:
•Hardware components suffer from the growing effects of many other
environmental factors. Stated simply, the hardware begins to wear out.
• Software is not susceptible to the environmental maladies that cause hardware
to wear out.
Characteristics of the Software
1. It is intangible, meaning it cannot be seen or touched.
2. It is non-perishable, meaning it does not degrade over time.
3. It is easy to replicate, meaning it can be copied and distributed easily.
4. It can be complex, meaning it can have many interrelated parts and features.
5. It can be difficult to understand and modify, especially for large and
complex systems.
6. It can be affected by changing requirements, meaning it may need to be
updated or modified as the needs of users change.
7. It can be impacted by bugs and other issues, meaning it may need to be
tested and debugged to ensure it works as intended.

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

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

Some Software Failures

Ariane 5
The Ariane 5 Rocket Failure (1996)
• Issue: A software error in the guidance system caused the rocket to explode 37
seconds after launch.
• Cause: The guidance software from the Ariane 4 was reused but was not
compatible with Ariane 5’s faster performance. A floating-point conversion
error led to a system crash.
• Impact: The failure cost around $370 million and delayed European space
programs.
5. Software Engineering Processes
Software Processes include those activities, methods, practices and
transformations that are used to create and maintain software products.
The software process is the way in which we produce software.
Process is what takes us from user needs to the software that satisfies the needs.
➢ A Software engineering process is the model chosen for managing the
creation of software from initial customer inception to the release of
the finished product. The chosen process usually involves techniques
such as -
▪ Analysis,
▪ Design,
▪ Coding,
▪ Testing and
▪ Maintenance
➢ In this engineering process, we trying to prevent the error at the time of
software development.

6. Software Engineering Processes Similarity and Differences

from Conventional Engineering Processes

Feature Software Conventional Similarity

Engineering Engineering
 Intangible (code, Tangible (bridges, Both produce
Nature of Product
algorithms, data). machines, buildings). functional systems.

Both follow a
Coding, debugging, Designing,prototyping,
Development systematic
testing, and manufacturing, and
Process development
deployment. construction.
approach.
Low (only High (materials like Both require
Material Costs computing resources steel, concrete, resources for
required). electronics). development.

Easy to update and Changes are costly and Both may require
Modification &
modify (patches, time-consuming after modifications over
Flexibility
upgrades). production. time.

Bugs can often be Failures (e.g., bridge Both require

Failure Impact fixed quickly with collapse) can be reliability to avoid
patches. catastrophic. failures.

Software testing Physical stress tests, Both involve

Testing &
(unit, integration, durability tests, safety rigorous testing
Validation
system, acceptance). inspections. before deployment.

Software can be Both aim for

Production & Each physical product
copied instantly at scalable
Duplication requires new materials.
minimal cost. production.

Less rigid; multiple Strict industry Both follow certain

Standardization development standards and best practices and
paradigms exist. regulations. standards.
Both follow a
Rapid development Longer product life
lifecycle from
Lifecycle Speed cycles; frequent cycle; changes are
design to
updates. difficult.
maintenance.
 Continuous updates,
Periodic maintenance, Both require long-
Maintenance bug fixes, security
repairs, and upgrades. term maintenance.
patches.
Repairs and
Easy to roll back to a Both need recovery
reconstruction are
Failure Recovery previous software mechanisms after
costly and time-
version. failures.
consuming.

Relies on computing Relies on physical Both require

Resource
resources (RAM, resources (materials, resource planning
Dependency
CPU, cloud). energy, labor). and management.

Both use structured

Agile, Waterfall, Traditional project
Project project
DevOps management (Lean, Six
Management management
methodologies. Sigma, PMP).
techniques.

7. Software Quality Attributes

In software engineering, software quality is an important aspect that determines the
success of a software product. Software quality encompasses various attributes and
practices that ensure a software product meets its intended requirements and user
expectations.
It is not just about functionality but also encompasses a broad range of attributes that
contribute to the overall excellence of a software product.
Software Quality Attributes:
Understanding the various software quality attributes is essential for comprehensively
grasping what constitutes good quality software.
• Portability: This refers to the ease with which software can be transferred from one
environment to another. It encompasses adaptability and flexibility in different
system environments.
 • Usability: It deals with how user-friendly the software is. A high level of usability
means the software is easy to learn, efficient to use, and pleasant in its
interactions.
• Reusability: This involves the software’s capability to be used in different
components or systems with minimal changes.
• Correctness: It relates to the accuracy and correctness of the software in performing
its intended functions.
• Maintainability: This indicates how easily software can be modified to correct faults,
improve performance, or adapt to a changed environment.
• Reliability: It means the degree to which a software system performs its required
functions under stated conditions for a specified period.
• Efficiency: This refers to the software’s ability to perform its functions without
wasting resources, including time and storage.
• Testability: It lets you easily know that software can be tested to make sure it
functions correctly to meet the requirements.

Role of Artificial Intelligence in Software Quality Assurance

The Artificial Intelligence (AI) and Machine Learning (ML) have transformed software
quality assurance. AI-driven techniques automate testing processes, predict defects, and
enhance software quality.
• Automated Testing: AI-powered test automation tools execute tests more efficiently
and comprehensively than manual testing.
• Predictive Analytics: An AI can predict potential defects and issues, allowing teams to
address them before they become critical.
• Continuous Monitoring: Artificial Intelligence monitors software performance and
identifies anomalies. With automated tests and monitoring it enables real-time
adjustments.
• Natural Language Processing (NLP): NLP techniques analyze user feedback and
sentiment, aiding in product improvement.
• Performance Optimization: The AI algorithms can optimize code and resource
allocation for better software performance.
• Bug Detection: AI-driven systems can identify and classify bugs, reducing the time and
effort required for debugging.

8. Software Development Life Cycle (SDLC)

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.
The goal of the SDLC life cycle model is to deliver high-quality, maintainable software
that meets the user’s requirements. SDLC in software engineering models outlines the
plan for each stage so that each stage of the software development model can perform its
task efficiently to deliver the software at a low cost within a given time frame that meets
users requirements. In this article we will see Software Development Life Cycle (SDLC)
in detail.
What is the Software Development Life Cycle (SDLC)?
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
SDLC specifies the task(s) to be performed at various stages by a software engineer or
developer. It ensures that the end product is able to meet the customer’s expectations and
fits within the overall budget. Hence, it’s vital for a software developer to have prior
knowledge of this software development process. SDLC is a collection of these six stages,
and the stages of SDLC are as follows:

Software Development Life Cycle Model SDLC Stages

The SDLC Model involves six phases or stages while developing any software.
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
obtained 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-1 : Planning and Requirement Analysis
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-2: Defining Requirements

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 3: Design
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 4: Development
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
the information repository necessary to know about software processes, functions, and
maintenance. Documentation also provides information about how to use the product.
Stage 5: Testing
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.

Stage 6: Deployment and Maintenance

8.1 Waterfall Model – Software Engineering

The Waterfall Model is a classical software development methodology. It was first
introduced by Winston W. Royce in 1970. It is a linear and sequential approach to software
development that consists of several phases. It must be completed in a specific order. This
classical waterfall model is simple and idealistic. It was once very popular. Today, it is not
that popularly used. However, it is important because most other types of software
development life cycle models are a derivative of this. In this article we will see the
waterfall model in detail.
What is the SDLC Waterfall Model?
The waterfall model is a software development model used in the context of large, complex
projects, typically in the field of information technology. It is characterized by a structured,
sequential approach to project management and software development.
The waterfall model is useful in situations where the project requirements are well-defined
and the project goals are clear. It is often used for large-scale projects with long timelines,
where there is little room for error and the project stakeholders need to have a high level
of confidence in the outcome.
Features of Waterfall Model
Following are the features of the waterfall model:
1. Sequential Approach: The waterfall model involves a sequential approach to
software development, where each phase of the project is completed before
moving on to the next one.
2. Document-Driven: The waterfall model depended on documentation to
ensure that the project is well-defined and the project team is working towards
a clear set of goals.
3. Quality Control: The waterfall model places a high emphasis on quality
control and testing at each phase of the project, to ensure that the final product
meets the requirements and expectations of the stakeholders.
4. Rigorous Planning: The waterfall model involves a careful planning process,
where the project scope, timelines, and deliverables are carefully defined and
monitored throughout the project lifecycle.
Overall, the waterfall model is used in situations where there is a need for a highly
structured and systematic approach to software development. It can be effective in
ensuring that large, complex projects are completed on time and within budget, with a
high level of quality and customer satisfaction.
Importance of Waterfall Model
Following are the importance of waterfall model:
1. Clarity and Simplicity: The linear form of the Waterfall Model offers a
simple and unambiguous foundation for project development.
 2. Clearly Defined Phases: The Waterfall Model phases each have unique
inputs and outputs, guaranteeing a planned development with obvious
checkpoints.
3. Documentation: A focus on thorough documentation helps with software
comprehension, maintenance, and future growth.
4. Stability in Requirements: Suitable for projects when the requirements are
clear and stable, reducing modifications as the project progresses.
5. Resource Optimization: It encourages effective task-focused work without
continuously changing contexts by allocating resources according to project
phases.
6. Relevance for Small Projects: Economical for modest projects with simple
specifications and minimal complexity.
Phases of Waterfall Model
The Waterfall Model has six phases which are:
1. Requirements: The first phase involves gathering requirements from
stakeholders and analyzing them to understand the scope and objectives of the
project.
2. Design: Once the requirements are understood, the design phase begins. This
involves creating a detailed design document that outlines the software
architecture, user interface, and system components.
3. Development: The Development phase includes implementation involving
coding the software based on the design specifications. This phase also
includes unit testing to ensure that each component of the software is working
as expected.
4. Testing: In the testing phase, the software is tested as a whole to ensure that
it meets the requirements and is free from defects.
5. Deployment: Once the software has been tested and approved, it is deployed
to the production environment.
6. Maintenance: The final phase of the Waterfall Model is maintenance, which
involves fixing any issues that arise after the software has been deployed and
ensuring that it continues to meet the requirements over time.
The classical waterfall model divides the life cycle into a set of phases. This model
considers that one phase can be started after the completion of the previous phase. That is
the output of one phase will be the input to the next phase. Thus the development process
can be considered as a sequential flow in the waterfall. Here the phases do not overlap
with each other. The different sequential phases of the classical waterfall model are shown
in the below figure.

Waterfall Model-Software Engineering

Let us now learn about each of these phases in detail which include further phases.
1. Feasibility Study
The main goal of this phase is to determine whether it would be financially and technically
feasible to develop the software. The feasibility study involves understanding the problem
and then determining the various possible strategies to solve the problem. These different
identified solutions are analyzed based on their benefits and drawbacks. The best solution
is chosen and all the other phases are carried out as per this solution strategy.
2. Requirements Analysis and Specification
The requirement analysis and specification phase aims to understand the exact
requirements of the customer and document them properly. This phase consists of two
different activities.
● Requirement gathering and analysis: Firstly all the requirements regarding
the software are gathered from the customer and then the gathered
requirements are analyzed. The goal of the analysis part is to remove
incompleteness (an incomplete requirement is one in which some parts of the
 actual requirements have been omitted) and inconsistencies (an inconsistent
requirement is one in which some part of the requirement contradicts some
other part).
● Requirement specification: These analyzed requirements are documented in
a software requirement specification (SRS) document. The SRS document
serves as a contract between the development team and customers. Any future
dispute between the customers and the developers can be settled by examining
the SRS document.
3. Design
The goal of this phase is to convert the requirements acquired in the SRS into a format that
can be coded in a programming language. It includes high-level and detailed design as
well as the overall software architecture. A Software Design Document is used to
document all of this effort (SDD).
4. Coding and Unit Testing
In the coding phase software design is translated into source code using any suitable
programming language. Thus each designed module is coded. The unit testing phase aims
to check whether each module is working properly or not.
5. Integration and System testing
Integration of different modules is undertaken soon after they have been coded and unit
tested. Integration of various modules is carried out incrementally over several steps.
During each integration step, previously planned modules are added to the partially
integrated system and the resultant system is tested. Finally, after all the modules have
been successfully integrated and tested, the full working system is obtained and system
testing is carried out on this. System testing consists of three different kinds of testing
activities as described below.
● Alpha testing: Alpha testing is the system testing performed by the
development team.
● Beta testing: Beta testing is the system testing performed by a friendly set of
customers.
● Acceptance testing: After the software has been delivered, the customer
performs acceptance testing to determine whether to accept the delivered
software or reject it.
6. Maintenance
Maintenance is the most important phase of a software life cycle. The effort spent on
maintenance is 60% of the total effort spent to develop a full software. There are three
types of maintenance.
● Corrective Maintenance: This type of maintenance is carried out to correct
errors that were not discovered during the product development phase.
● Perfective Maintenance: This type of maintenance is carried out to enhance
the functionalities of the system based on the customer’s request.
● Adaptive Maintenance: Adaptive maintenance is usually required for
porting the software to work in a new environment such as working on a new
computer platform or with a new operating system.
Advantages of Waterfall Model
The classical waterfall model is an idealistic model for software development. It is very
simple, so it can be considered the basis for other software development life cycle models.
Below are some of the major advantages of this SDLC model.
● Easy to Understand: The Classical Waterfall Model is very simple and easy
to understand.
● Individual Processing: Phases in the Classical Waterfall model are processed
one at a time.
● Properly Defined: In the classical waterfall model, each stage in the model
is clearly defined.
● Clear Milestones: The classical Waterfall model has very clear and well-
understood milestones.
● Properly Documented: Processes, actions, and results are very well
documented.
● Reinforces Good Habits: The Classical Waterfall Model reinforces good
habits like define-before-design and design-before-code.
● Working: Classical Waterfall Model works well for smaller projects and
projects where requirements are well understood.
Disadvantages of Waterfall Model
The Classical Waterfall Model suffers from various shortcomings: we can't use it in real
projects, but we use other software development lifecycle models which are based on the
classical waterfall model. Below are some major drawbacks of this model.
● No Feedback Path: In the classical waterfall model evolution of software
from one phase to another phase is like a waterfall. It assumes that no error is
ever committed by developers during any phase. Therefore, it does not
incorporate any mechanism for error correction.
● Difficult to accommodate Change Requests: This model assumes that all
the customer requirements can be completely and correctly defined at the
beginning of the project, but the customer’s requirements keep on changing
with time. It is difficult to accommodate any change requests after the
requirements specification phase is complete.
● No Overlapping of Phases: This model recommends that a new phase can
start only after the completion of the previous phase. But in real projects, this
can’t be maintained. To increase efficiency and reduce cost, phases may
overlap.
● Limited Flexibility: The Waterfall Model is a rigid and linear approach to
software development, which means that it is not well-suited for projects with
changing or uncertain requirements. Once a phase has been completed, it is
difficult to make changes or go back to a previous phase.
● Limited Stakeholder Involvement: The Waterfall Model is a structured and
sequential approach, which means that stakeholders are typically involved in
the early phases of the project (requirements gathering and analysis) but may
not be involved in the later phases (implementation, testing, and deployment).
● Late Defect Detection: In the Waterfall Model, testing is typically done
toward the end of the development process. This means that defects may not
be discovered until late in the development process, which can be expensive
and time-consuming to fix.

When to Use a Waterfall Model?

Here are some cases where the use of the Waterfall Model is best suited:
 ● Well-understood Requirements: Before beginning development, there are
precise, reliable, and thoroughly documented requirements available.
● Very Little Changes Expected: During development, very little adjustments
or expansions to the project’s scope are anticipated.
● Small to Medium-Sized Projects: Ideal for more manageable projects with
a clear development path and little complexity.
● Predictable: Projects that are predictable, low-risk, and able to be addressed
early in the development life cycle are those that have known, controllable
risks.
● Regulatory Compliance is Critical: Circumstances in which paperwork is
of utmost importance and stringent regulatory compliance is required.

Applications of Waterfall Model

Here are some application of SDLC waterfall model:
● Safety-Critical Systems: The Waterfall Model is often used in the
development of safety-critical systems, such as aerospace or medical systems,
where the consequences of errors or defects can be severe.
● Government and Defense Projects: The Waterfall Model is also commonly
used in government and defense projects, where a rigorous and structured
approach is necessary to ensure that the project meets all requirements and is
delivered on time.
● Projects with well-defined Requirements: The Waterfall Model is best
suited for projects with well-defined requirements, as the sequential nature of
the model requires a clear understanding of the project objectives and scope.
● Projects with Stable Requirements: The Waterfall Model is also well-suited
for projects with stable requirements, as the linear nature of the model does
not allow for changes to be made once a phase has been completed.
8.2 Prototype Model
Prototyping is defined as the process of developing a working replication of a product or
system that has to be engineered. It offers a small-scale facsimile of the end product and
is used for obtaining customer feedback. The Prototyping concept is described below:
The Prototyping Model is one of the most popularly used Software Development Life
Cycle Models (SDLC models). This model is used when the customers do not know the
exact project requirements beforehand. In this model, a prototype of the end product is
first developed, tested, and refined as per customer feedback repeatedly till a final
acceptable prototype is achieved which forms the basis for developing the final product.

Prototyping Model-Concept
In this process model, the system is partially implemented before or during the analysis
phase thereby allowing the customers to see the product early in the life cycle. The process
starts by interviewing the customers and developing the incomplete high-level paper
model. This document is used to build the initial prototype supporting only the basic
functionality as desired by the customer. Once the customer figures out the problems, the
prototype is further refined to eliminate them. The process continues until the user
approves the prototype and finds the working model to be satisfactory.
Steps of Prototyping Model
Step 1: Requirement Gathering and Analysis: This is the initial step in designing a
prototype model. In this phase, users are asked about what they expect or what they want
from the system.
Step 2: Quick Design: This is the second step in the Prototyping Model. This model covers
the basic design of the requirement through which a quick overview can be easily
described.
Step 3: Build a Prototype: This step helps in building an actual prototype from the
knowledge gained from prototype design.
Step 4: Initial User Evaluation: This step describes the preliminary testing where the
investigation of the performance model occurs, as the customer will tell the strengths and
weaknesses of the design, which was sent to the developer.
Step 5: Refining Prototype: If any feedback is given by the user, then improving the
client’s response to feedback and suggestions, the final system is approved.
Step 6: Implement Product and Maintain: This is the final step in the phase of the
Prototyping Model where the final system is tested and distributed to production, where
the program is run regularly to prevent failures.

Types of Prototyping Models

There are four types of Prototyping Models, which are described below.
● Rapid Throwaway Prototyping
● Evolutionary Prototyping
● Incremental Prototyping
● Extreme Prototyping
1. Rapid Throwaway Prototyping
● This technique offers a useful method of exploring ideas and getting customer
feedback for each of them.
● In this method, a developed prototype need not necessarily be a part of the
accepted prototype.
 ● Customer feedback helps prevent unnecessary design faults and hence, the
final prototype developed is of better quality.
2. Evolutionary Prototyping
● In this method, the prototype developed initially is incrementally refined
based on customer feedback till it finally gets accepted.
● In comparison to Rapid Throwaway Prototyping, it offers a better approach
that saves time as well as effort.
● This is because developing a prototype from scratch for every iteration of the
process can sometimes be very frustrating for the developers.
3. Incremental Prototyping
● In this type of incremental prototyping, the final expected product is broken
into different small pieces of prototypes and developed individually.
● In the end, when all individual pieces are properly developed, then the
different prototypes are collectively merged into a single final product in their
predefined order.
● It’s a very efficient approach that reduces the complexity of the development
process, where the goal is divided into sub-parts and each sub-part is
developed individually.
● The time interval between the project’s beginning and final delivery is
substantially reduced because all parts of the system are prototyped and tested
simultaneously.
● Of course, there might be the possibility that the pieces just do not fit together
due to some lack of ness in the development phase – this can only be fixed by
careful and complete plotting of the entire system before prototyping starts.
4. Extreme Prototyping
This method is mainly used for web development. It consists of three sequential
independent phases:
● In this phase, a basic prototype with all the existing static pages is presented
in HTML format.
 ● In the 2nd phase, Functional screens are made with a simulated data process
using a prototype services layer.
● This is the final step where all the services are implemented and associated
with the final prototype.
This Extreme Prototyping method makes the project cycling and delivery robust and fast
and keeps the entire developer team focused and centralized on product deliveries rather
than discovering all possible needs and specifications and adding necessitated features.
Advantages of Prototyping Model
● The customers get to see the partial product early in the life cycle. This ensures
a greater level of customer satisfaction and comfort.
● New requirements can be easily accommodated as there is scope for
refinement.
● Missing functionalities can be easily figured out.
● Errors can be detected much earlier thereby saving a lot of effort and cost,
besides enhancing the quality of the software.
● The developed prototype can be reused by the developer for more complicated
projects in the future.
● Flexibility in design.
Disadvantages of the Prototyping Model
● Costly concerning time as well as money.
● There may be too much variation in requirements each time the prototype is
evaluated by the customer.
● Poor Documentation due to continuously changing customer requirements.
● It is very difficult for developers to accommodate all the changes demanded
by the customer.
● There is uncertainty in determining the number of iterations that would be
required before the prototype is finally accepted by the customer.
● After seeing an early prototype, the customers sometimes demand the actual
product to be delivered soon.
 ● Developers in a hurry to build prototypes may end up with sub-optimal
solutions.
8.3 Spiral Model
The Spiral Model is one of the most important Software Development Life Cycle models.
The Spiral Model is a combination of the waterfall model and the iterative model. It
provides support for Risk Handling. The Spiral Model was first proposed by Barry
Boehm. 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, it looks like a spiral with many loops. The exact number of loops of the
spiral is unknown and can vary from project to project. Each loop of the spiral is called a
phase of the software development process.
Some Key Points regarding the phase of a Spiral Model:
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 the 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. Objectives Defined: In the first phase of the spiral model we clarify what
the project aims to achieve, including functional and non-functional
requirements.
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. Objective 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 are 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 is the Spiral Model called the 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.

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.

8.4 Evolutionary Model

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. The Evolution 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 explained in depth to the developer team.
2. There might be small changes required in separate parts but not a major
change.
3. As it requires time, there must be some time left for the market constraints.
4. Risk is high and continuous targets to achieve and report to customers
repeatedly.
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.
 8.5 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.
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.

Life-
Cycle of Iterative Enhancement Model
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
accommodating 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, reducing 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 products.
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:
1. 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.
2. 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 develop features incrementally and guarantee 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.
3. E-commerce Platforms: Development in the e-commerce field often
involves constant updates. Implementing an iterative approach enables the
introduction of new functionality.
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.

Iterative vs Incremental Model-Differences:

Here are the key differences between the iterative and incremental model (iterative
enhancement model):-
 Aspect Iterative Model Incremental Model
(Iterative
Enhancement Model)

Development Repetitive cycles with Delivering the software

Approach continuous refinement in functional parts

Flexibility Highly flexible and Offers flexibility but less

adaptive to changes than iterative

Testing Testing is integrated Testing is done for each

throughout the cycle increment

Delivery of Complete features are Features are delivered

Features developed in each incrementally
iteration

Risk Risks are identified and Risks are managed as

Management addressed in each increments are delivered
cycle

Client Feedback is collected Feedback is obtained

Feedback and incorporated after each increment
regularly
 Project Provides a clearer view Offers visible progress
Visibility of the project's with each delivered
progress increment

Dependency Dependencies can be Dependencies between

Management identified and resolved increments need careful
in each iteration management

Completion May take longer to Allows for partial

Time deliver the complete delivery in shorter time
product frames

Example Writing a draft and Building a house floor by

Analogy refining it multiple floor
times

Which is better- Iterative or Incremental Model ?

The choice between Iterative and Incremental models in software development is not a
matter of one being universally better than the other. Both models have their strengths and
weaknesses, and the suitability of each depends on the specific requirements of the project.
 SHORT QUESTIONS
1. Define generic software with example. 2023
2. Define software components. 2023
3. Define the term Software Engineering. 2022
4. Discuss the various characteristics of a software. 2022
5. Enlist characteristics of software. 2021
6. Define SDLC. 2021
7. Define software crisis. 2021
8. What do you understand by software crisis? 2017
9. What are different software quality attributes? 2017
10.What is the software crisis? 2016
11.Write major software characteristics. 2016
12.Write the differences between software and software engineering. 2016

LONG QUESTIONS
1. Explain Software Quality Attributes in detail. 2023
2. Explain SDLC. Also discuss various activities during SDLC. 2023
3. Illustrate the statement “Software engineering is layered technology”. 2022
4. Explain prototyping model of SDLC. What are its advantages over conventional
model? Explain with diagram. 2022
5. Discuss Spiral Model for Software development life cycle and highlight the Risk
analysis in this context. 2022
6. What is the need of SDLC? Discuss evolutionary development model in detail with
the help of diagram. 2021
7. Explain iterative waterfall and spiral model for software life cycle and discuss various
activities in each phase. 2018
8. List several software process paradigms. Explain how both waterfall model and
prototyping model can be accommodated in the spiral process model.
2018
9. Which is more important-the product or process? Justify your answer. 2018
10. Explain Spiral Model? Also write it’s advantages and disadvantages. 2017
11. Explain different phases of SDLC. 2017
12. Explain Iterative Enhancement Model. Write its advantages and disadvantages. 2017
13. Explain software development life cycle. Discuss various activities during SDLC.
2016
14. What are the characteristics of a software process? 2016
15. Define the following: (i) Water fall Model (ii) Spiral Model 2016