Software Engineering

(KCS-601)
UNIT - 1
B. Tech CSE 6th SEM
By: Prateek Agarwal
 Software

 Software refers to a set of instructions or programs that tell a computer how

to perform specific tasks. It encompasses all the intangible components of
a computer system, including applications, operating systems, utilities, and
other programs. Software can be categorized into two main types: system
software, which manages the computer hardware and provides a platform
for other software, and application software, which performs specific tasks
for the user.
 Examples of software include word processors, web browsers, games,
operating systems (like Windows or macOS), and various applications used
in business, education, entertainment, and more.
 Engineering

 Engineering is a broad discipline that involves the application of scientific

and mathematical principles to design, build, analyze, and maintain
structures, systems, devices, and processes. It encompasses various
branches, such as civil engineering, mechanical engineering, electrical
engineering, and more, each dealing with different aspects of technology
and infrastructure.
 Engineering involves a systematic and disciplined approach to problem-
solving, emphasizing creativity, innovation, and practical application of
knowledge. Engineers use mathematical and scientific principles to design
and build solutions that address specific needs or challenges.
 Software Engineering

 Software engineering is a discipline within the field of computer science

that focuses on the systematic design, development, testing, maintenance,
and documentation of software applications and systems. It involves the
application of engineering principles to software development, with the
goal of creating reliable, efficient, and scalable software solutions.
 Software engineers use various methodologies, tools, and programming
languages to carry out these tasks. They work collaboratively in teams to
develop software that meets the specified requirements and standards.
Communication and documentation are crucial throughout the software
development life cycle to ensure that the development process is well-
understood and that the software can be maintained and enhanced in
the future.
 Key aspects of software engineering include:
 Requirements Analysis: Understanding and defining the software
requirements based on the needs of users and stakeholders.
 Design: Creating a blueprint or plan for the software, specifying how
different components will interact and how the system will meet its
requirements.
 Implementation: Writing the actual code based on the design, following
best practices and coding standards.
 Testing: Verifying that the software behaves as expected, identifying and
fixing bugs, and ensuring the quality and reliability of the software.
 Maintenance: Making modifications and updates to the software as
needed to address changing requirements, fix issues, and improve
performance.
 Project Management: Planning, organizing, and managing the resources,
schedule, and tasks associated with software development projects.
Key Principles of Software Engineering
 Modularity: Breaking the software into smaller, reusable components that can be developed and tested
independently.
 Abstraction: Hiding the implementation details of a component and exposing only the necessary
functionality to other parts of the software.
 Encapsulation: Wrapping up the data and functions of an object into a single unit, and protecting the internal
state of an object from external modifications.
 Reusability: Creating components that can be used in multiple projects, which can save time and resources.
 Maintenance: Regularly updating and improving the software to fix bugs, add new features, and address
security vulnerabilities.
 Testing: Verifying that the software meets its requirements and is free of bugs.
 Design Patterns: Solving recurring problems in software design by providing templates for solving them.
 Agile methodologies: Using iterative and incremental development processes that focus on customer
satisfaction, rapid delivery, and flexibility.
 Continuous Integration & Deployment: Continuously integrating the code changes and deploying them
into the production environment.
Objectives of Software Engineering
 Maintainability: It should be feasible for the software to evolve to meet changing requirements.
 Efficiency: The software should not make wasteful use of computing devices such as memory,
processor cycles, etc.
 Correctness: A software product is correct if the different requirements specified in the SRS
Document have been correctly implemented.
 Reusability: A software product has good reusability if the different modules of the product can
easily be reused to develop new products.
 Testability: Here software facilitates both the establishment of test criteria and the evaluation of
the software with respect to those criteria.
 Reliability: It is an attribute of software quality. The extent to which a program can be expected
to perform its desired function, over an arbitrary time period.
 Portability: In this case, the software can be transferred from one computer system or
environment to another.
 Adaptability: In this case, the software allows differing system constraints and the user needs to
be satisfied by making changes to the software.
 Interoperability: Capability of 2 or more functional units to process data cooperatively.
NEED OF SOFTWARE ENGINEERING

 The need of software engineering arises because of higher rate of change in user
requirements and environment on which the software is working.
 Large software - It is easier to build a wall than to a house or building, likewise, as the size of
software become large engineering has to step to give it a scientific process.
 Scalability- If the software process were not based on scientific and engineering
concepts, it would be easier to re-create new software than to scale an existing one.
 Cost- As hardware industry has shown its skills and huge manufacturing has lower down the
price of computer and electronic hardware. But the cost of software remains high if proper
process is not adapted.
 Dynamic Nature- The always growing and adapting nature of software hugely depends
upon the environment in which the user works. If the nature of software is always changing,
new enhancements need to be done in the existing one. This is where software
engineering plays a good role.
 Quality Management- Better process of software development provides better and quality
software product
Advantages of Software Engineering
There are several advantages to using a systematic and disciplined approach to software
development, such as:
 Improved Quality: By following established software engineering principles and techniques, the
software can be developed with fewer bugs and higher reliability.
 Increased Productivity: Using modern tools and methodologies can streamline the development
process, allowing developers to be more productive and complete projects faster.
 Better Maintainability: Software that is designed and developed using sound software
engineering practices is easier to maintain and update over time.
 Reduced Costs: By identifying and addressing potential problems early in the development
process, software engineering can help to reduce the cost of fixing bugs and adding new
features later on.
 Increased Customer Satisfaction: By involving customers in the development process and
developing software that meets their needs, software engineering can help to increase customer
satisfaction.
 Better Team Collaboration: By using Agile methodologies and continuous integration, software
engineering allows for better collaboration among development teams.
 Better Scalability: By designing software with scalability in mind, software engineering can help to
ensure that software can handle an increasing number of users and transactions.
 Better Security: By following the Software Development Life Cycle (SDLC) and performing security
testing, software engineering can help to prevent security breaches and protect sensitive data.
CHARACTERESTICS OF GOOD SOFTWARE

A software product can be judged by what it offers and how well it can be
used. This software must satisfy on the following grounds:
 Operational
 Transitional
 Maintenance
Operational

This tells us how well software works in operations. It can be measured on:
 Budget
 Usability
 Efficiency
 Correctness
 Functionality
 Dependability
 Security
 Safety
Transitional

This aspect is important when the software is moved from one platform to
another:
 Portability
 Interoperability
 Reusability
 Adaptability
Maintenance

This aspect briefs about how well a software has the capabilities to maintain
itself in the ever-changing environment:
 Modularity
 Maintainability
 Flexibility
 Scalability

In short, Software engineering is a branch of computer science, which uses

well-defined engineering concepts required to produce efficient, durable,
scalable, in-budget and on-time software products
 Functionality:
 Example: A word processing software (e.g., Microsoft Word) should correctly handle tasks such as
text formatting, spell-checking, and document printing.
 Usability:
 Example: A mobile banking application should have an intuitive user interface, allowing users to
easily check their account balance, transfer funds, and pay bills.
 Efficiency:
 Example: An image editing software (e.g., Adobe Photoshop) should process and apply filters to
images efficiently, ensuring quick response times for user interactions.
 Maintainability:
 Example: A content management system (e.g., WordPress) should have modular components,
making it easy for developers to update and add new features without disrupting the entire
system.
 Portability:
 Example: A cross-platform messaging application (e.g., WhatsApp) allows users to send messages,
images, and videos across different operating systems like iOS and Android.
 Reliability:
 Example: An online reservation system for airlines should be fault-tolerant, ensuring that users can
complete their bookings even if there are temporary issues with the system.
 Security:
 Example: An online banking application should employ encryption techniques to
secure users' personal and financial information during transactions.
 Flexibility:
 Example: An e-commerce platform should be adaptable to changes in product
catalogs, pricing structures, and promotional offers without requiring significant code
modifications.
 Interoperability:
 Example: Web browsers like Google Chrome or Mozilla Firefox should be able to
render and display websites consistently, regardless of the web development
technologies used.
 Scalability:
 Example: A social media platform (e.g., Facebook) should be capable of handling an
increasing number of users, posts, and interactions as its user base grows.
 Testability:
 Example: An automated testing suite for a software application should be designed to
easily run a variety of tests, checking for correctness and identifying potential issues.
 Reusability:
 Example: A software library that provides common algorithms (e.g., sorting algorithms)
can be reused across multiple projects without the need for redevelopment.
Program vs. Software &
Software Components
 Software is more than programs. Any program is a subset of software, and it
becomes software only if documentation & operating procedures manuals
are prepared.
 There are three components of the software as shown in fig:
 1. Program: Program is a combination of source code & object code.
 2. Documentation: Documentation consists of different types of manuals.
Examples of documentation manuals are: Data Flow Diagram, Flow Charts,
ER diagrams, etc.
 3. Operating Procedures: Operating Procedures consist of instructions to set
up and use the software system and instructions on how react to the system
failure. Example of operating system procedures manuals is: installation
guide, Beginner's guide, reference guide, system administration guide, etc.
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 arise because existing methods were insufficient.
Causes of Software Crisis

 The cost of owning and maintaining software was as expensive as developing

the software.
 At that time Projects were running overtime.
 At that time Software was very inefficient.
 The quality of the software was low quality.
 Software often did not meet user requirements.
 The average software project overshoots its schedule by half.
 At that time Software was never delivered.
 Non-optimal resource utilization.
 Challenging to alter, debug, and enhance.
 The software complexity is harder to change.
Solution of Software Crisis

There is no single solution to the crisis. One possible solution to a software crisis
is Software Engineering because software engineering is a systematic,
disciplined, and quantifiable approach. For preventing software crises, there
are some guidelines:
 Reduction in software over budget.
 The quality of the software must be high.
 Less time is needed for a software project.
 Experienced and skilled people working on the software project.
 Software must be delivered.
 Software must meet user requirements.
 Software Engineering Process and
Conventional Engineering Process
Conventional Engineering Process
 Conventional Engineering Process is an engineering process that is highly
based on empirical knowledge and is about building cars, machines, and
hardware. It is a process that mainly involves science, mathematics, etc.
Software Engineering Process
 Software Engineering Process is an engineering process that is mainly
related to computers and programming and developing different kinds of
applications through the use of information technology.
Similarities Between Software Engineering
Process and Conventional Engineering
Process
 Both Software Engineering and Conventional Engineering Processes
become automated after some time.
 Both these processes are making our day-to-day place better.
 Both these processes have a fixed working time.
 Both processes must consist of deeper knowledge.
 Aspect Software Engineering Process Conventional Engineering Process
Engineers in both fields follow structured
Both involve a systematic approach to problem- methodologies to design, build, and maintain systems
Systematic Approach solving and project execution or products
Initial phase involves gathering and analyzing Detailed requirements analysis is crucial to
Requirement Analysis requirements understanding project goals and constraints
Involves creating detailed plans or blueprints for the Designing components, structures, or systems based
Design Phase final product or system on specifications and requirements

The actual creation of the product or system Physical construction or assembly of components
Implementation/Construction according to design specifications based on engineering drawings and plans

Rigorous testing to ensure the product or system Testing procedures to validate the performance,
Testing and Quality Assurance meets quality standards safety, and reliability of the final product

Both require effective project management for Project managers play a crucial role in planning,
Project Management scheduling, resource allocation, and risk mitigation organizing, and controlling projects in both domains

Documentation is essential for recording design Thorough documentation of engineering drawings,

Documentation decisions, code, and project progress specifications, and project documentation
Both follow a lifecycle with distinct phases, from Phases such as planning, design, construction, testing,
Lifecycle Phases conception to maintenance and maintenance are common to both
Engineers from different disciplines (e.g., civil,
Collaboration between various disciplines (e.g., mechanical, electrical) collaborate on interdisciplinary
Interdisciplinary Collaboration software developers, architects, testers) projects

Emphasis on learning from experiences, feedback, and Continuous improvement through lessons learned,
Continuous Improvement improving processes feedback, and adapting processes for future projects
Engineers in both fields employ problem-solving
A problem-solving mindset is crucial for addressing techniques to address design and construction
Problem-solving Approach challenges and optimizing solutions challenges
Adherence to industry-specific quality standards and Compliance with standards such as ISO, ASME, or
Quality Standards best practices ASTM, depending on the industry
 Differences Between Software
Engineering Process and Conventional
Engineering Process
 Aspect Software Engineering Process Conventional Engineering Process
Nature of Product Intangible, non-physical product (code) Tangible, physical product (e.g., bridge, car)
Virtual, using integrated development environments Physical, involving materials, prototypes, and physical
Development Environment (IDEs) and simulation tools testing
Highly flexible, iterative development with frequent Typically more rigid, with fewer opportunities for
Flexibility and Iteration updates and releases iteration once construction begins

Emphasis on extensive testing, including unit, Testing involves physical prototypes and validation
Testing and Validation integration, and system testing through real-world experiments and tests

Easier to accommodate changes during the Changes can be costly and time-consuming, often
Change Management development process requiring significant redesign and rework

Prototyping is less common, especially in large-scale

Prototyping Commonly used for early validation and user feedback projects with physical components

Shorter lifecycle, with rapid development cycles and Longer lifecycle, especially in construction projects,
Lifecycle Duration continuous updates with more emphasis on planning and execution
Documentation is important but may not be as
Comprehensive documentation is crucial for detailed, with more emphasis on physical plans and
Documentation Emphasis understanding and maintaining code specifications

Collaboration is often distributed, and teams may Collaboration often involves co-located teams, with
Collaboration and Team Dynamics work remotely face-to-face communication more common
Cost is more concentrated on human resources, tools, Cost involves materials, labor, equipment, and physical
Cost Structure and software licenses infrastructure
Compliance may be related to software standards and Compliance often involves industry-specific
Regulatory Compliance regulations regulations and safety standards

Risks may be related to technology, changing Risks involve uncertainties in material properties,
Risks and Uncertainties requirements, or market dynamics environmental conditions, and unforeseen challenges

Continuous customer involvement, feedback, and Customer involvement may be periodic, with more
Customer Involvement adaptation to changing needs focus on initial requirements and periodic updates
“The process of developing software for
simulating a bridge design and physically
building a bridge”
Similarities:
 Both involve a structured process: Both software development and bridge construction follow a
step-by-step process to achieve their goals.
 Testing is important: Whether it's testing the stability of a physical bridge or ensuring the
accuracy of a software simulation, testing plays a crucial role in both cases.
 Documentation is necessary: Both projects require documentation to keep track of plans,
designs, and any changes made during the process.
Differences:
 Materials and tools: In bridge construction, we use physical materials like steel and concrete,
while in software development, we use programming languages and computer software.
 Testing methods: While both projects involve testing, the methods used are different. For a
physical bridge, we might conduct stress tests and inspections, while for software, we use
techniques like unit testing and code reviews.
 Lifecycle phases: The phases of development differ. Building a bridge involves planning,
construction, and maintenance, while software development includes requirements analysis,
coding, testing, and deployment.
 Regulatory compliance: Bridge construction must adhere to building codes and safety
regulations, whereas software development may need to comply with data privacy laws and
industry standards.
 Software Engineering Process

It is a engineering process which is mainly related to computers and programming and

developing different kinds of applications through the use of information technology.
There are four basic key process activities:
 1.Software Specifications –In this process, detailed description of a software system to be
developed with its functional and non-functional requirements.
 2.Software Development –In this process, designing, programming, documenting, testing,
and bug fixing is done.
 3.Software Validation –In this process, evaluation software product is done to ensure that
the software meets the business requirements as well as the end users needs.
 4.Software Evolution – It is a process of developing software initially, then timely
updating it for various reasons.
 Layered Technology in Software
Engineering
Software engineering is a fully layered technology, to develop software we need to go from one layer
to another. All the layers are connected and each layer demands the fulfillment of the previous layer.
Layer 1 — Tools
The first layer involves choosing the semi-automated and automated tools that will become the
framework for the project. It provides integrity that means providing security to the software so
that data can be accessed by only an authorized person, no outsider can access the data. It also
focuses on maintainability and usability.
Example: Integrated Development Environment (IDE), Visual Studio Code (VS Code)

Layer 2 —Method
The second layer establishes the methods of developing the software. This includes any
technical knowledge and resources required for development. Some tasks include choosing
methods for:
 Communication
 Analysis
 Modeling
 Program construction
 Testing and support
Example: Test-Driven Development (TDD), Writing unit tests for a login functionality
Layer 3 — Process
 Layer three focuses on the framework that needs to be established to deliver software
effectively. This layer can be broken down into five sub layers:

Example: Agile Software Development, Scrum FrameworkDescription: Scrum is an Agile

framework that defines roles, events, and artifacts for managing software development
projects. In a real-life scenario, a software development team may use the Scrum framework to
organize their work, conduct daily stand-up meetings, and deliver working software at the end
of each sprint.
Layer 4 — A Quality Focus
 At this point, the software is developed and refined to a point, but it is critical to apply
quality control to the finished product. Besides testing the end product to ensure that it
meets the client’s specifications, it also needs real-world testing to determine how efficient,
usable, and reusable it will be, and it needs to explore how much resource maintenance will
require.
Example:
Code Reviews
Description: Code reviews involve inspecting and evaluating source code to identify defects,
improve code quality, and ensure compliance with coding standards. They can be conducted
manually or using automated tools.
Peer Code Reviews
Description: In a software development team, developers conduct peer code reviews to
examine each other's code for errors, readability, and adherence to coding standards. By
providing feedback and suggestions for improvement, code reviews help maintain code quality
and prevent issues from being introduced into the codebase.
Quality Attributes
The following factors are used to measure Software Development Quality.
Each attribute can be used to measure product performance. These attributes can be used for Quality
assurance as well as Quality control:
1) Reliability
Measure if the product is reliable enough to sustain in any condition
2) Maintainability
Different versions of the product should be easy to maintain. For development, it should be easy to
add code to the existing system, should be easy to upgrade for new features and new technologies
from time to time.
3) Usability
This can be measured in terms of ease of use. The application should be user-friendly. It should be
easy to learn. Navigation should be simple.
4) Portability
This can be measured in terms of Costing issues related to porting, Technical issues related to
porting, and Behavioral issues related to porting.
5) Correctness
The application should be correct in terms of its functionality, calculations used internally and the
navigation should be correct. This means that the application should adhere to functional
requirements.
6) Efficiency
It is measured in terms of time required to complete any task given to the system.
7) Integrity or Security
Integrity comes with security. System integrity or security should be sufficient to prevent
unauthorized access to system functions, prevent information loss, ensure that the software is
protected from virus infection, and protect the privacy of data entered into the system.
8) Testability
The system should be easy to test and find defects. If required, it should be easy to divide into
different modules for testing.
9) Flexibility
Should be flexible enough to modify
 (SDLC)
SOFTWARE DEVELOPMENT LIFE CYCLE
 SDLC is a methodical approach to developing software that ensures its
quality and correctness.
 The SDLC process is designed to provide high-quality software that satisfies
customer requirements and ensures system development is completed within
the schedule and budget constraints.
 SDLC is a detailed plan that describes how to plan, construct, and maintain
specific software.
 An SDLC Model is a diagrammatic and graphical depiction of the software
life cycle. It represents all of the procedures required to move a software
product through the stages of its life cycle.
 It also captures the structure in which these procedures will be carried out. In
other words, it maps the many actions performed on a software product from
its inception through its retirement.
Phase 1: Requirement Collection

 The requirement collection step of the SDLC is the most important and basic one.
 Senior team members oversee it, with feedback coming from the
 client or customer,
 the sales division,
 market research,
 and industry experts.
 The fundamental project strategy is then planned using this data, and product feasibility studies are
carried out on a range of topics covered in the following stage of the SDLC methodology.
 Understanding the business use case of the software product requires having completed the
requirement collection process.
 To gather all the information, including what the customer wants to build, who the end user will
be, and what function the product will serve, the business analyst schedules a meeting with the
client.
 Before creating the product, one must have a basic understanding of it. Identifying project risks
and getting ready for quality assurance requirements are also part of the planning process.
Phase 2: Defining requirements and Feasibility Study

Following the completion of the requirement collection, the next stage is to explicitly describe and
record the product needs and obtain approval from the client or market analysts. This is accomplished
through the SRS (Software Requirement Specification) document, which includes all the product
requirements to be defined and developed throughout the project life cycle. Once the SRS document is
prepared, the requirements are evaluated for feasibility checks over these parameters:

 Economical: Can we finish the project within the budget?

 Legal: Can we handle this project in light of cyber law and other regulatory
frameworks/compliances?
 Operation feasibility: Can we construct the activities that the client expects?
 Technical: Determine whether the current computer system is capable of supporting the software.
 Schedule: Determine whether or not the project can be completed within the time frame specified.
Phase 3: Design

 In this phase, the SRS document is used as input to prepare the DDS - Design Document
Specification.
 Software architects use the requirements defined in SRS as a reference to come up with the best
architecture for the product being developed. Ideally, multiple design approaches are proposed and
documented in the DDS.
 All essential stakeholders review this DDS, and the optimal design strategy for the product is
chosen based on many characteristics such as
 risk assessment,
 product robustness,
 design modularity,
 budget, and
 time restrictions.
 A design approach explicitly outlines all of the product's architectural components, as well as its
communication and data flow representation with external and third-party modules.
 The internal design of all components of the proposed architecture should be explicitly
documented in DDS down to the smallest detail.
Phase 4: Coding
In this phase, the developer receives the design document, and the software design is converted into
source code in the most appropriate high-level programming language. It can be called the most
prolonged phase of SDLC.

Phase 5: Testing
 Once the coding phase is over and the modules are ready for testing, they are deployed in the
testing environment and tested against the requirements to ensure that the products address the
needs identified and obtained during the requirements stage.
 Unit testing, integration testing, system testing, and acceptability testing are all performed during
this stage.
 The QA (Quality Assurance) and testing teams may discover faults or defects, which they report to
developers.
 The development team fixes the bug and sends it back to QA for another round of testing.
 This procedure is repeated retesting and regression testing) until the program is bug-free, stable,
and meets the system's business requirements.
 Testers refer to the SRS document to ensure that the software meets the customer's standard.
Phase 6: Installation/Deployment
Once the testing phase is over and no bugs or errors are left in the system, the deployment process
starts. Following testing, the overall design of the software will be completed.
Through developer efforts, various modules or designs will be integrated into the core source code,
typically by employing training environments to find further faults or defects.
Finally, the information system will be integrated into its environment. After clearing this stage, the
program is theoretically market-ready and can be distributed to any end user.

Phase 7: Maintenance
Once the built software is deployed, issues might arise while the code runs in the production
environment and need to be solved on the go. In SDLC models, this is called the maintenance phase of
a software project, and it consists of mainly three activities-
 Bug fixing - bugs or errors arising due to unforeseen circumstances which were not taken care of
during testing.
 Upgrading to newer versions
 Enhancement - adding new features
The focus of this phase is to ensure that needs continue to be met and that the system continues to
perform as per the requirements collected in the first phase.
 Why use SDLC?

 SDLC models are by project managers to form a basis for planning,

scheduling, and estimating the life cycle of an IT project.
 They use SDLC models to outline the various stages required in
software development and ensure every stage is finished on time and
the software product meets the quality standards.
 The development of a software product would not be systematic and
disciplined if a precise SDLC model is not used.
 When a team produces a software product, team members must grasp
when and what to do. Otherwise, it would be an indication of turmoil
and project failure.
 SDLC Models
WE ARE GOING TO DISCUSS
 Waterfall Model
 Prototype Model
 Spiral Model
 Evolutionary Development Models
 Iterative Enhancement Models
 Waterfall Model
 The Waterfall Model was the first Process Model to be introduced. It is also
referred to as a linear-sequential life cycle model. It is very simple to understand
and use. In a waterfall model, each phase must be completed before the next phase
can begin and there is no overlapping in the phases.

 The Waterfall model is the earliest SDLC approach that was used for software
development.

 The Waterfall Model illustrates the software development process in a linear

sequential flow. This means that any phase in the development process begins
only if the previous phase is complete. In this waterfall model, the phases do not
overlap.
 Waterfall Model
 The Waterfall Model was first described by Dr. Winston W. Royce in a paper titled
"Managing the Development of Large Software Systems," which was presented at
a conference in 1970. However, it's important to note that Dr. Royce's paper
actually presented the Waterfall Model as an example of a flawed approach to
software development, cautioning against its strict sequential nature.
 Despite its initial criticism, the Waterfall Model gained popularity as a software
development methodology, and its concept of sequential phases has influenced
subsequent approaches to software engineering. While Dr. Royce did not intend
for the Waterfall Model to become a standard practice, it has since become one of
the most well-known and widely used models in software engineering.
Waterfall Model - Design
Waterfall approach was first
SDLC Model to be used
widely in Software
Engineering to ensure success
of the project. In "The
Waterfall" approach, the
whole process of software
development is divided into
separate phases. In this
Waterfall model, typically, the
outcome of one phase acts as
the input for the next phase
sequentially.
The sequential phases in Waterfall model are −
 Requirement Gathering and analysis − All possible requirements of the system
to be developed are captured in this phase and documented in a requirement
specification document.
 System Design − The requirement specifications from first phase are studied in
this phase and the system design is prepared. This system design helps in
specifying hardware and system requirements and helps in defining the overall
system architecture.
 Implementation − With inputs from the system design, the system is first
developed in small programs called units, which are integrated in the next phase.
Each unit is developed and tested for its functionality, which is referred to as Unit
Testing.
 Integration and Testing − All the units developed in the implementation phase
are integrated into a system after testing of each unit. Post integration the entire
system is tested for any faults and failures.
 Deployment of system − Once the functional and non-functional testing is done;
the product is deployed in the customer environment or released into the market.
 Maintenance − There are some issues which come up in the client environment.
To fix those issues, patches are released. Also to enhance the product some better
versions are released. Maintenance is done to deliver these changes in the
customer environment.

All these phases are cascaded to each other in which progress is seen as flowing
steadily downwards (like a waterfall) through the phases. The next phase is started
only after the defined set of goals are achieved for previous phase and it is signed off,
so the name "Waterfall Model". In this model, phases do not overlap.
Waterfall Model - Application

Every software developed is different and requires a suitable SDLC approach to be

followed based on the internal and external factors. Some situations where the use of
Waterfall model is most appropriate are −
 Requirements are very well documented, clear and fixed.
 Product definition is stable.
 Technology is understood and is not dynamic.
 There are no ambiguous requirements.
 Ample resources with required expertise are available to support the product.
 The project is short.
Waterfall Model - Advantages
The advantages of waterfall development are that it allows for departmentalization and control.
A schedule can be set with deadlines for each stage of development and a product can proceed
through the development process model phases one by one.
Some of the major advantages of the Waterfall Model are as follows −
 Simple and easy to understand and use
 Easy to manage due to the rigidity of the model. Each phase has specific deliverables and a
review process.
 Phases are processed and completed one at a time.
 Works well for smaller projects where requirements are very well understood.
 Clearly defined stages.
 Well understood milestones.
 Easy to arrange tasks.
 Process and results are well documented.
Waterfall Model - Disadvantages
The disadvantage of waterfall development is that it does not allow much reflection or revision.
Once an application is in the testing stage, it is very difficult to go back and change something that
was not well-documented or thought upon in the concept stage.
The major disadvantages of the Waterfall Model are as follows −
 No working software is produced until late during the life cycle.
 High amounts of risk and uncertainty.
 Not a good model for complex and object-oriented projects.
 Poor model for long and ongoing projects.
 Not suitable for the projects where requirements are at a moderate to high risk of changing. So,
risk and uncertainty is high with this process model.
 It is difficult to measure progress within stages.
 Cannot accommodate changing requirements.
 Adjusting scope during the life cycle can end a project.
 Integration is done as a "big-bang. at the very end, which doesn't allow identifying any
technological or business bottleneck or challenges early.
 Example: Developing a Mobile Application
Imagine you're part of a software development team tasked with creating a mobile application for a client.
You decide to follow the Waterfall Model for the software development project.
 Requirements Gathering Phase:
 You begin by gathering requirements from the client, including the features, functionality, user interface, and
target audience for the mobile application.
 Based on the requirements, you create a detailed software requirements specification (SRS) document outlining
the scope of the project and the specific features and functionalities to be implemented.
 Design Phase:
 With the requirements in hand, you move on to the design phase. Here, you create detailed wireframes, mock-
ups, and user interface (UI) designs for the mobile application.
 The design phase ensures that the user experience (UX) and interface design are carefully planned and aligned
with the client's requirements and expectations.
 Implementation Phase:
 Once the design is finalized, you begin the implementation phase, where actual coding and development work
takes place.
 Software developers write code to implement the features and functionalities specified in the requirements and
design documents, following coding standards and best practices.
 Example: Developing a Mobile Application
 Testing Phase:
 After the development is complete, you conduct thorough testing of the mobile application to ensure that it
functions correctly and meets quality standards.
 This may involve various types of testing, including unit testing, integration testing, system testing, and user
acceptance testing (UAT), to identify and fix any defects or issues.
 Deployment Phase:
 Finally, once the mobile application passes all tests and meets the client's requirements, it is ready for
deployment to the app stores.
 The mobile application is released to users, who can download and install it on their devices, and any remaining
tasks, such as marketing or support, are completed.

In summary, the Waterfall Model for software engineering involves following a sequential flow of phases,
where each phase must be completed before moving to the next. Requirements are gathered upfront, and
planning is meticulous to ensure that development proceeds smoothly and according to plan. While the
Waterfall Model provides structure and clarity, it may lack flexibility in accommodating changes or
unexpected challenges that arise during the development process.
 Spiral Model
SDLC or Software Development Life Cycle in software engineering
consists of several models. The Spiral model is one of the most
important ones. The model or approach is known to manage risks
better. It mixes the iterative process model with specific elements of
the waterfall model. The spiral model is a diagram that looks like a coil
with loops. The number of loops in this model depends on the project
and is chosen by the project manager. Each loop dedicates a phase in
software development.
 Spiral Model

The Spiral Model was introduced by Dr. Barry Boehm in 1986. Dr.
Boehm, a prominent figure in the field of software engineering,
proposed the Spiral Model as an iterative approach to software
development that emphasizes risk management and evolutionary
prototyping. His work on the Spiral Model was published in his
seminal paper titled "A Spiral Model of Software Development and
Enhancement." Since then, the Spiral Model has become one of the
well-known and widely used models in the field of software
engineering.
The Spiral Model is a flexible and iterative approach to software development that emphasizes risk
management and allows for incremental development.
Here's a step-by-step explanation of the Spiral Model:
 Planning:
 The project begins with the identification of objectives, constraints, and alternatives. This phase involves
defining the scope of the project, establishing goals, and determining the resources needed.
 Key activities include defining project requirements, identifying stakeholders, and establishing project
milestones.
 Risk Analysis:
 In this phase, potential risks are identified and assessed. Risks may include technical challenges, changing
requirements, resource constraints, or external factors such as market conditions.
 Risk analysis involves evaluating the probability and impact of each risk and developing strategies to mitigate or
manage them.
 Development:
 Once risks are identified and mitigated, development begins. This phase involves designing, coding, and testing
the software according to the project requirements.
 Incremental development occurs, with each iteration adding new features or enhancements to the software.
 Evaluation:
 After each iteration of development, the software is evaluated to assess its functionality, quality, and compliance
with requirements.
 Evaluation may involve testing the software, gathering feedback from stakeholders, and reviewing project
progress against established criteria.
 Iteration:
 The Spiral Model follows an iterative approach, with multiple cycles or iterations of planning, risk analysis,
development, and evaluation.
 Each iteration builds upon the previous one, incorporating feedback, addressing issues, and refining the software
based on lessons learned.
 Closure:
 The project concludes with a final evaluation and review of the software. Any remaining issues or concerns are
addressed, and the software is prepared for deployment or delivery to the client.
 Lessons learned from the project are documented, and recommendations for future projects may be made.
Key Features of the Spiral Model

 Flexibility: The Spiral Model allows for flexibility in accommodating changes and uncertainties
throughout the development process.
 Risk Management: The model emphasizes risk management and mitigation, with a focus on
identifying and addressing potential risks early in the project lifecycle.
 Iterative Development: Development occurs in iterative cycles, with each iteration resulting in
an improved version of the software.
 Customer Feedback: Stakeholder involvement and feedback are integral to the Spiral Model,
ensuring that the software meets user needs and expectations.

In summary, the Spiral Model is a cyclical approach to software development that balances risk
management with iterative development. It provides a structured framework for managing complex
projects while allowing for flexibility and adaptation to changing requirements and circumstances.
 Example: Developing a Mobile Application Using the Spiral Model
 Planning:
 Objective: Develop a mobile application for a ride-sharing service.
 Scope: The application will allow users to request rides, track driver locations, and make payments.
 Constraints: Limited development time and budget.
 Risk Analysis:
 Identified Risks:
 Technical: Integration with third-party mapping APIs may be complex.
 Requirements: Client may request changes to features during development.
 Market: Competitors may release similar applications with advanced features.
 Mitigation Strategies:
 Technical: Conduct thorough research and testing of mapping APIs before integration.
 Requirements: Maintain open communication with the client and document all change requests.
 Market: Monitor competitor activity and differentiate the application with unique features.
 Development:
 First Iteration:
 Develop basic user interface (UI) for the mobile application.
 Implement core features such as user registration, ride request, and driver tracking.
  Second Iteration:

Enhance UI design based on user feedback from the first iteration.

Add additional features such as in-app messaging and driver ratings.
 Subsequent Iterations:

Continue adding features and refining the application based on user feedback and
stakeholder input.
Address any technical issues or bugs that arise during development.
 Evaluation:
 User Testing: Conduct usability testing with a group of beta users to gather feedback on the application's
functionality and usability.
 Stakeholder Review: Present the application to stakeholders for review and feedback on the overall progress
and alignment with project objectives.
 Iterative Improvements: Incorporate feedback and make necessary adjustments to the application's design and
functionality based on evaluation results.
 Iteration:
 Iterative Cycle: Repeat the development, evaluation, and iteration process for each cycle of the Spiral Model.
 Continuous Improvement: Each iteration builds upon the previous one, with new features and enhancements
added based on user feedback and changing requirements.
 Closure:
 Final Review: Conduct a final review of the application to ensure that all requirements have been met and that it
meets quality standards.
 Deployment: Release the application to app stores for public use, making it available to users for download and
installation on their mobile devices.
 Post-Deployment Support: Provide ongoing support and maintenance for the application, addressing any issues
or bugs that may arise after deployment.
Real-life examples where the Spiral Model can be applied:
 Space Exploration Projects:
 When developing spacecraft or satellites for space exploration missions, the Spiral Model can be applied to manage the
complexity and uncertainty inherent in such projects. Each phase of the Spiral Model can correspond to different stages of
spacecraft development, including design, prototyping, testing, and deployment. The iterative nature of the model allows for
continuous refinement and adaptation as new challenges and requirements arise during the development process.
 Medical Device Development:
 In the development of medical devices such as implantable devices or diagnostic equipment, the Spiral Model can be used to
address regulatory requirements, safety concerns, and evolving user needs. The model's iterative approach enables developers to
iteratively design, test, and refine prototypes while incorporating feedback from medical professionals, regulatory bodies, and
end-users. This iterative and risk-driven approach helps ensure that the final product meets stringent safety and performance
standards.
 Infrastructure Projects:
 Large-scale infrastructure projects, such as the construction of bridges, highways, or power plants, can benefit from the Spiral
Model's risk management and iterative development approach. Each phase of the Spiral Model can correspond to different stages
of project planning, design, construction, and maintenance. By identifying and mitigating risks early in the project lifecycle,
stakeholders can make informed decisions and adapt plans as needed to ensure project success.
 Defense Systems Development:
 The development of defense systems, including military vehicles, aircraft, or missile systems, often involves complex
requirements, evolving threats, and strict performance criteria. The Spiral Model can be employed to manage the development of
such systems by iteratively designing, testing, and refining prototypes while addressing technical challenges and regulatory
requirements. This iterative and risk-driven approach enables defense contractors to deliver high-quality and reliable systems that
meet the needs of military stakeholders.
 Environmental Conservation Projects:
 Environmental conservation projects, such as ecosystem restoration initiatives or climate change mitigation efforts, require
adaptive management strategies to address changing environmental conditions and stakeholder priorities. The Spiral Model can
be applied to these projects by iteratively planning, implementing, and evaluating conservation actions while considering
ecological, social, and economic factors. This iterative and collaborative approach helps conservation practitioners learn from
past experiences and adjust strategies to achieve long-term environmental goals.
Advantages of Spiral Model
 Risk Management: The Spiral Model emphasizes risk management by identifying
potential risks early in the development process and incorporating risk mitigation strategies
into each iteration. This helps minimize project risks and uncertainties.
 Flexibility: The model allows for flexibility in accommodating changes and evolving
requirements throughout the development lifecycle. It can adapt to changing market
conditions, technology advancements, and stakeholder feedback.
 Iterative Development: Iterative development allows for continuous improvement and
refinement of the software through multiple cycles or iterations. Each iteration builds upon
the previous one, resulting in a more robust and feature-rich product.
 Stakeholder Involvement: Stakeholder involvement is integral to the Spiral Model,
ensuring that user needs and expectations are considered throughout the development
process. This leads to greater satisfaction and acceptance of the final product.
 Early Prototyping: The model encourages early prototyping and user feedback, allowing
stakeholders to visualize and interact with the software early in the development process.
This helps identify and address usability issues and requirements gaps.
Disadvantages of Spiral Model
 Complexity: The Spiral Model can be more complex and resource-intensive compared to other
software development models. It requires thorough risk analysis, planning, and coordination,
which may increase project overhead.
 Cost and Time: The iterative nature of the model may result in increased development costs and
timeframes, especially if iterations require significant rework or changes to the software
architecture.
 Documentation Overhead: Managing documentation and project artifacts throughout multiple
iterations can be challenging and may lead to documentation overhead. Maintaining alignment
between project documentation and evolving requirements is essential but can be time-
consuming.
 Dependency on Risk Analysis: The success of the Spiral Model relies heavily on the
effectiveness of risk analysis and mitigation strategies. Inaccurate or inadequate risk assessment
may lead to project delays, budget overruns, or quality issues.
 Not Suitable for Small Projects: The Spiral Model may not be suitable for small-scale or
straightforward projects where the overhead of risk management and iterative development
outweighs the benefits.
 Limitations of Spiral Model
 Not Ideal for Fixed Requirements: The Spiral Model may not be suitable for projects with fixed
or well-defined requirements, as its iterative nature is better suited to projects with evolving or
uncertain requirements.
 Dependency on Experienced Teams: Successful implementation of the Spiral Model requires
experienced and skilled development teams capable of conducting thorough risk analysis, planning,
and coordination.
 Limited Scalability: The model may face scalability challenges when applied to large-scale or
complex projects, as managing multiple iterations and dependencies can become more difficult to
coordinate.
 Management Oversight: Effective project management and oversight are crucial for the success of
the Spiral Model. Without proper governance and control, projects may veer off track or fail to meet
objectives.
 Potential for Scope Creep: The iterative nature of the model may lead to scope creep if changes
and enhancements are continually introduced without proper evaluation or prioritization.
In summary, while the Spiral Model offers several advantages, including effective risk management,
flexibility, and stakeholder involvement, it also has inherent disadvantages and limitations, such as
complexity, cost, and dependency on risk analysis. Understanding these factors is essential for
determining whether the Spiral Model is the right fit for a particular software development project.
Why Spiral Model is called Meta Model?

 The Spiral model is called a Meta-Model because it subsumes all the other
SDLC models.
 For example, a single loop spiral actually represents the Iterative Waterfall
Model.
 The spiral model incorporates the stepwise approach of the Classical Waterfall
Model.
 The spiral model uses the approach of the Prototyping Model by building a
prototype at the start of each phase as a risk-handling technique.
 Also, the spiral model can be considered as supporting the Evolutionary model
–the iterations along the spiral can be considered as evolutionary levels through
which the complete system is built.
 Prototype Model
 Prototyping is a generic way of creating a functional replica of
any idea, software, or system requiring more engineering to produce
the final result.
 The prototype model will provide a miniature replica of your desired
end product, requiring accurate consumer feedback to be crafted
accordingly.
 A prototype of an application often demonstrates the usability of any
product in the development phase, although it may not contain the
exact requirements of the desired outcome.
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, here the program is run regularly to
prevent failures.
 The Prototyping Model is one of the most often used SDLC Models. It is applied
when customers do not know the exact project requirements ahead of time.
 In this paradigm, a prototype of the eventual product is created, tested, and refined
based on consumer feedback until a final acceptable prototype is reached, which
serves as the foundation for building the final product.
 The process begins with client interviews and the creation of a high-level
document.
 This document is used to create the initial prototype, which will only offer the
minimal capabilities requested by the customer.
 The system is partly developed before or during the analysis phase, allowing
clients to experience the product early in its life cycle.
 Once the customer has identified the issues, the prototype is improved to eliminate
them.
 The process is repeated until the user approves the prototype and is satisfied with
the working model.
A prototype is a toy and crude implementation of a system. It has limited
functional capabilities, low reliability, or inefficient performance as compared to
the actual software. A prototype can be built very quickly by using several
shortcuts by developing inefficient, inaccurate or dummy functions.

Necessity of the Prototyping Model –

 It is advantageous to develop the Graphical User Interface (GUI) part of a
software using the Prototyping Model. Through prototype, the user can
experiment with a working user interface and they can suggest any change if
needed.
 The prototyping model is especially useful when the exact technical solutions are
unclear to the development team. A prototype can help them to critically examine
the technical issues associated with the product development. The lack of
familiarity with a required development technology is a technical risk. This can be
resolved by developing a prototype to understand the issues and accommodate the
changes in the next iteration.
 Prototype Development – Prototype development starts with an initial
requirements gathering phase. A quick design is carried out and a prototype is
built. The developed prototype is submitted to the customer for evaluation. Based
on the customer feedback, the requirements are refined and the prototype is
suitably modified. This cycle of obtaining customer feedback and modifying the
prototype continues till the customer approves the prototype.
 Iterative Development – Once the customer approves the prototype, the actual
software is developed using the iterative waterfall approach. In spite of the
availability of a working prototype, the SRS document is usually needed to be
developed since the SRS Document is invaluable for carrying out tractability
analysis, verification and test case design during later phases.
The code for the prototype is usually thrown away. However, the experience gathered
from developing the prototype helps a great deal in developing the actual software.
By constructing the prototype and submitting it for user evaluation, many customer
requirements get properly defined and technical issues get resolved by experimenting
with the prototype. This minimises later change requests from the customer and the
associated redesign costs.
Types of Prototyping Models

There are four types of Prototyping Models, which are described

below:-
1) Rapid Throwaway Prototyping
2) Evolutionary Prototyping
3) Incremental Prototyping
4) 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 fineness 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 Prototype Model
 Early Feedback: The Prototype Model allows stakeholders to visualize and interact with a basic version of
the software early in the development process. This facilitates early feedback from users, clients, and other
stakeholders, which can help identify requirements, validate design decisions, and refine the software's
functionality.
 Requirement Validation: Prototypes serve as tangible representations of the software's features and
functionalities. By demonstrating the prototype to stakeholders, developers can validate requirements,
clarify expectations, and ensure that the final product meets user needs and expectations.
 Risk Reduction: Prototyping helps mitigate project risks by uncovering potential issues, technical
challenges, and usability concerns early in the development lifecycle. By addressing these issues during the
prototyping phase, developers can minimize the likelihood of costly rework and delays later in the project.
 Iterative Refinement: The Prototype Model supports iterative development, allowing developers to refine
the software incrementally based on feedback and changing requirements. This iterative approach enables
continuous improvement and ensures that the final product aligns with stakeholder expectations.
 Enhanced Communication: Prototypes facilitate communication and collaboration among project
stakeholders by providing a common reference point for discussions. By visualizing the software's
functionality and design, stakeholders can better understand project goals, make informed decisions, and
align their expectations.
Disadvantages of Prototype Model
 An unstable/badly implemented prototype often becomes the final product.
 Require extensive customer collaboration
 Costs customer money
 Needs committed customer
 Difficult to finish if customer withdraw
 May be too customer specific, no broad market
 Difficult to know how long the project will last.
 Easy to fall back into the code and fix without proper requirement analysis, design, customer
evaluation, and feedback.
 Prototyping tools are expensive.
 Special tools & techniques are required to build a prototype.
 It is a time-consuming process.
 Applications of Prototype Model
 User Interface Design: Prototyping is commonly used in user interface (UI) and user experience (UX) design
to create mock-ups and wireframes of software interfaces. This helps designers visualize layout, navigation, and
interaction patterns before final implementation.
 Software Requirements Elicitation: Prototyping facilitates requirements elicitation by providing stakeholders
with concrete examples of proposed features and functionalities. By interacting with prototypes, stakeholders
can provide feedback and refine requirements based on their needs and preferences.
 Proof of Concept: Prototyping is used to validate the feasibility and technical viability of proposed solutions.
By building prototypes, developers can test hypotheses, evaluate technical approaches, and identify potential
challenges before committing to full-scale development.
 Iterative Development: Prototyping supports iterative development approaches, such as Agile and Lean
methodologies, by enabling continuous feedback and refinement of the software. Developers can build and test
prototypes in short cycles, incorporating feedback and making adjustments based on user input.
 Training and Demonstrations: Prototypes can be used for training purposes, allowing users to familiarize
themselves with software features and workflows before the final product is deployed. Additionally, prototypes
can be used to demonstrate software capabilities to potential clients, investors, or stakeholders.
 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.
Iterative Enhancement Model

 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
Iterative Enhancement Model
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

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

 Especially in larger projects, managing several iterations at once can

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

 Mobile app development: Updates and improvements are often needed for mobile apps to stay
current with new devices, operating system versions and user preferences. By using an iterative
process developers can release the beta versions of their apps, get user feedback and then improve
functionality of those iterations in future release.
 Web Application Development: The requirements for developing web applications frequently
change as a result of shifting user demand and advancements in technology. The Iterative
Enhancement Model makes it possible to developed features incrementally and guaranteeing that
the application can be modified to satisfy changing user and market demands. In later iterations it
also makes it easier to incorporate new features based on input from users.
 E-commerce Platforms: Development in e-commerce field often involves constant updates.
Implementing an iterative approach enables the introduction of new functionality.
 Conclusion
In the conclusion, the Iterative enhanced model has advantages
such as delivery, reducing risk, checking quality, and flexibility.
But it also has drawbacks like complexity, conflict deadlines,
increased expenses, documentation problems. Determing
whether to use this model in light of the particular requirements
and properties of the software developement project requires an
understanding of both of its benefits and drawbacks.
 Evolutionary Development 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.
 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.
 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.
 Therefore, the software product evolves with time.
 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.
 The evolutionary model solves this problem with a different approach.
 The evolutionary model suggests breaking down work into smaller chunks, prioritizing them, and then
delivering those chunks to the customer one by one.
 The number of chunks is huge and is the number of deliveries made to the customer.
 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.
 The model allows for changing requirements as well as all work is broken down into maintainable work
chunks.
 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.
 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.
 Therefore, the software product evolves with time.
 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.
 The evolutionary model solves this problem with a different approach.
 The evolutionary model suggests breaking down work into smaller chunks, prioritizing them, and then
delivering those chunks to the customer one by one.
 The number of chunks is huge and is the number of deliveries made to the customer.
 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.
 The model allows for changing requirements as well as all work is broken down into maintainable work
chunks.
Application of Evolutionary Model

 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.
 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
 Customer needs are clear and been explained in deep to the developer team.
 There might be small changes required in separate parts but not a major change.
 As it requires time, so there must be some time left for the market constraints.
 Risk is high and continuous targets to achieve and report to customer repeatedly.
 It is used when working on a technology is new and requires time to learn.
Advantages Evolutionary Model

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

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

 The evolutionary model is a helpful framework in the quickly evolving field of software
development, where requirements are frequently modified and user expectations change.
As with any development process, optimizing the advantages and minimizing the possible
negatives of evolutionary models in software engineering requires careful evaluation of
project-specific considerations.

 Master Software Testing and Automation in an efficient and time-bound manner by

mentors with real-time industry experience. Join our Software Automation Course and
embark on an exciting journey, mastering the skill set with ease!