Software Engineering

Dr. Sachin Kumar Yadav

UNIT I Hours: 7

Introduction: Introduction to software engineering, Software

characteristics, Software components, Software applications, Software
Crisis, Software metrics and measurement, project monitoring and
control, Software life cycle models, Waterfall, Prototype, Incremental
model, Iterative enhancement Model, Spiral Models, Agile model,
Introduction to SE Tools: Git and Eclipse
What is software?
• Computer programs and associated documentation
What is software?
 Documentation consists of different types of manuals
are
Formal Specification
Analysis Context-
/Specification Diagram
Data Flow
Diagrams
Flow
Design
Charts
Documentation Entity-Relationship
Manuals Diagram
Source Code Listings
Implementation Cross-Reference
Listing
Test Data
Testing
Test Results

List of documentation manuals

Operating Procedures consists of different types of
manuals are
System Overview
User Beginner’s Guide
Manuals Tutorial
Reference Guide

Operating
Procedures

Installation Guide
Operational
Manuals
S
y
s
t
e
m
A
d
Software Product
• Software products
may be
developed for a
particular customer or may be
developed for a general market
 What is software engineering?
Software engineering is an engineering discipline which
is concerned with all aspects of software production
Software engineers should
– adopt a systematic and organised approach to their
work
– use appropriate tools and techniques depending on
• the problem to be solved,
• the development constraints and
– use the resources available
 What is software engineering?
At the first conference on software engineering in 1968, Fritz
Bauer defined software engineering as “The establishment and
use of sound engineering principles in order to obtain
economically developed software that is reliable and works
efficiently on real machines”.

Stephen Schach defined the same as “A discipline whose aim is

the production of quality software, software that is delivered on
time, within budget, and that satisfies its requirements”.

Both the definitions are popular and acceptable to majority. However, due to increase in
cost of maintaining software, objective is now shifting to produce quality software that is
maintainable, delivered on time, within budget, and also satisfies its requirements.
Introduction to Software Engineering
CONT…
• Software engineering is the branch of computer science that deals
with the design, development, testing, and maintenance
of software applications.
• Software Engineering is an engineering branch related to the
evolution of software product using well-defined scientific principles,
techniques, and procedures.
• 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.
 Software Process
The software process is the way in
which we produce
software.

Why is it difficult to improve software

process ?
• Not enough time
• Lack of knowledge
• Wrong motivations
• Insufficient commitment
Software Characteristics:
Software does not wear out.

Burn-in
phase Wear out
phase

Failure Intensity
Useful life
phase

Time
Software Characteristics:
Comparison of constructing a bridge vis-à-vis writing a
program.
Sr. No Constructing a bridge Writing a program

1. The problem is well understood Only some parts of the problem

2.
There are many existing bridges
3. The requirement for a bridge
typically do not change much during
construction
4. The strength and stability of a bridge
can be calculated with reasonable
precision
5. When a bridge collapses,
there is a detailed
investigation and report
6. Engineers have been constructing
bridges for thousands of years
7. Materials (wood, stone,iron, steel)
and techniques (making joints in
wood, carving stone, casting iron)
change slowly.
are understood, others are not
Every program is different and designed for
special applications.
Requirements typically change during
all phases of development.
Not possible to calculate correctness of a
program with existing methods.
When a program fails, the reasons are often
unavailable or even deliberately concealed.
Developers have been writing programs
for 50 years or so.
Hardware and software changes rapidly.
Characteristics (Component of S/W
characteristics) of software engineering
Functionality
Functionality refers to the set of
features and capabilities that a
software program or system
provides to its users. It is one of the
most important characteristics of
software, as it determines the
usefulness of the software for the
intended purpose.
Examples:
Data storage and retrieval
Data processing and manipulation
User interface and navigation
Communication and networking
Security and access control
Reporting and visualization
Automation and scripting
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 Examples of factors that can affect the
aspect of software quality, as it reliability of software include:
1.Bugs and errors in the code
helps ensure that the software 2.Lack of testing and validation
will work correctly and not fail 3.Poorly designed algorithms and data
structures
unexpectedly. 4.Inadequate error handling and recovery
5.Incompatibilities with other software or
hardware
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
Examples of factors that can affect the efficiency of the
way. software include:
1.Poorly designed algorithms and data structures
2.Inefficient use of memory and processing power
3.High network latency or bandwidth usage
4.Unnecessary processing or computation
5.Unoptimized code
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.
Required functions are:
 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.
Required functions are:
Portability
A set of attributes that bears on the ability of software to be transferred
from one environment to another, without minimum changes.
• Required functions are:
Importance of software engineering
software applications
Software Crisis
Software crisis is a term used in the
early days of computing science
for the difficulty of writing useful and
efficient computer programs in the
required time. The software crisis was
due to the rapid increases in computer
power and the complexity of the
problems that could not be tackled.
CONT…
Factors Contributing to Software Crisis
• Poor project management.
• Lack of adequate training in software engineering.
• Less skilled project members.
• Low productivity improvements.
Solution of Software Crisis
There is no single solution to the crisis. One possible solution to a
software crisis is software engineering, because software engineering is
a systematic, disciplined, and quantifiable approach. For preventing
software crises, there are some guidelines:
• Reduction in software over budget.
• The quality of the software must be high.
• Less time is needed for a software project.
• Experienced and skilled people working on the software project.
• Software must be delivered.
• Software must meet user requirements.
Some Software failures
Ariane 5
It took the European Space Agency 10
years and $7 billion to produce Ariane 5,
a giant rocket capable of hurling a pair of
three-ton satellites into orbit with each
launch and intended to give Europe
overwhelming supremacy in the
commercial space business.

The rocket was destroyed after 39 seconds

of its launch, at an altitude of two and a
half miles along with its payload of four
expensive and uninsured scientific
satellites.
Some Software failures
When the guidance system’s own
computer tried to convert one
piece of data the sideways velocity
of the rocket from a 64 bit format
to a 16 bit format; the number was
too big, and an overflow error
resulted after 36.7 seconds. When
the guidance system shutdown, it
passed control to an identical,
redundant unit, which was there to
provide backup in case of just such
a failure. Unfortunately, the
second
unit, which had failed in the
identical manner a few
milliseconds before.
Some Software failures
Y2K problem:

It was simply the ignorance about the

adequacy or otherwise of using only
last two digits of the year.

The 4-digit date format, like 1964,

was shortened to 2-digit format, like
64.
Some Software failures
The Patriot Missile
o First time used in Gulf war
o Used as a defense from Iraqi Scud
missiles
o Failed several times including one that
killed 28 US soldiers in Dhahran, Saudi
Arabia
Reasons:
A small timing error in the system’s clock
accumulated to the point that after 14 hours,
the tracking system was no longer accurate.
In the Dhahran attack, the system had been
operating for more than 100 hours.
 Some Software failures
The Space Shuttle
Part of an abort scenario for the
Shuttle requires fuel dumps to lighten
the spacecraft. It was during the
second of these dumps that a
(software) crash occurred.
...the fuel management module, which
had performed one dump and
successfully exited, restarted when
recalled for the second fuel dump...
Role of Management in SoftwareDevelopment
Factors of Management Dependency in Software Development

Factors

People
Project

Product Process
Role of Management in Software Development

People

Project 4 Dependency Product

2
Order

Process
• People – When we refer to people in software development, we actually mean
hierarchy of roles in software development such as managers, team leaders,
senior developers etc.
• They are ones who form development team and work in development of software.
The order of priority of people among other dependency factors is first (highest).
Software development is people-centric activity.
• Software development requires good managers, people who understand
psychology of people and provide good leadership. A good manager does not
ensure success of project, but can increase probability of success.
• A good manager gives priority to areas like proper selection, training,
compensation, career development, work culture, development team’s efficiency
etc.
• Therefore, Managers are crucial and critical for software development and it is
their responsibility to manage, motivate, encourage, control and guide his/her
development team through tough situations. Hence, success of project is on
shoulders of people who are involved in development.
• Product – A product is solution of problem that is handed to user who is
struggling with problem. The priority of product among other dependency
factors is second that is after people.
• The product or solution to problem is constructed based on requirements, which
are objectives and scope work of problem. This helps managers to select best
approach within constraints imposed by delivery deadlines, budgetary
restrictions, personnel availability, technical interfaces etc.
• Without well defined requirements, it may be impossible to define reasonable
estimates of cost, development time and schedule for project.
• Process – The process is way in which we produce software. It
provides framework from which comprehensive plan for software
development can be established.
• If process is weak, end product will undoubtedly suffer. The priority
of process among other dependency factors is third,
after people and product, however, it plays very critical role for
success of project.
• There are many life cycle models and process improvements models.
A suitable process model is determined on basis of requirements
specification, development team, user, type of project and
associated risks of project.
• Project – A proper planning is required to monitor status of
development and to control complexity. For project to be successful,
it should be within budget, follow policies and requirements
defined, and completed within timeline stated.
• Most of projects overrun cost by 100% of budget and are not
delivered on time. The priority of project among other dependency
factors is last(lowest). In order to manage successful project, we must
understand and prevent associated risks.
• Concrete requirements should be defined and frozen, wherever
possible. Unnecessary changes should not be made to avoid software
surprises. Software surprises are always risky and should be
minimized. A planning mechanism should be constructed to caution
from occurrence of any surprises.
Software Process and Product Metrics
Process metrics quantify the attributes of softwaredevelopment
•process and environment;
•whereas product metrics are measures for the software product.
•Examples
•Process metrics: Productivity, Quality, Efficiency etc.
• Product metrics: Size, Reliability, Complexity etc.
 Software measurement and metrics
• A Measurement is an indication of the size, quantity, amount or
dimension of a particular attribute of a product or process.
• For example the number of errors in a system is a measurement.

• A Metric is a measurement of the degree that any attribute belongs

to a system, product or process.
• For example the number of errors per person hours would be a
metric.
Software Measurement
A measurement is an indication of the size, quantity, amount or dimension
of a particular attribute of a product or process.
For example the number of errors in a system is a measurement.
Software Measurement Principles:

The software measurement process can be characterized by five activities-

1.Formulation: The derivation of software measures and metrics appropriate for the representation of the software
that is being considered.

2.Collection: The mechanism used to accumulate data required to derive the formulated metrics.

3.Analysis: The computation of metrics and the application of mathematical tools.

4.Interpretation: The evaluation of metrics results in insight into the quality of the representation.

5.Feedback: Recommendation derived from the interpretation of product metrics transmitted to the software team.
Need for Software Measurement
• Create the quality of the current product or process.
• Anticipate future qualities of the product or process.
• Enhance the quality of a product or process.
• Regulate the state of the project concerning budget and schedule.
• Enable data-driven decision-making in project planning and control.
• Identify bottlenecks and areas for improvement to drive process
improvement activities.
• Ensure that industry standards and regulations are followed.
• Give software products and processes a quantitative basis for
evaluation.
• Enable the ongoing improvement of software development practices.
Classification of Software Measurement
• Direct Measurement: In direct measurement, the product, process,
or thing is measured directly using a standard scale.
• Indirect Measurement: In indirect measurement, the quantity or
quality to be measured is measured using related parameters i.e. by
use of reference.
Software Metrics

• A Metric is a measurement of the degree that any attribute belongs

to a system, product or process.
• Software metrics is a quantifiable or countable assessment of the
attributes of a software product. There are 4 functions related to
software metrics:
• Planning
• Organizing
• Controlling
• Improving
Characteristics of software Metrics:
• Quantitative: Metrics must possess quantitative nature. It means metrics can
be expressed in numerical values.
• Understandable: Metric computation should be easily understood, and the
method of computing metrics should be clearly defined.
• Applicability: Metrics should be applicable in the initial phases of the
development of the software.
• Repeatable: When measured repeatedly, the metric values should be the
same and consistent in nature.
• Economical: The computation of metrics should be economical.
• Language Independent: Metrics should not depend on any programming
language.
Classification of Software Metrics
• Product Metrics: Product metrics are used to evaluate the state of the product, tracing risks and undercover
prospective problem areas. The ability of the team to control quality is evaluated. Examples include lines of
code, cyclomatic complexity, code coverage, defect density, and code maintainability index.

• Process Metrics: Process metrics pay particular attention to enhancing the long-term process of the team or
organization. These metrics are used to optimize the development process and maintenance activities of
software. Examples include effort variance, schedule variance, defect injection rate, and lead time.

• Project Metrics: The project metrics describes the characteristic and execution of a project. Examples
include effort estimation accuracy, schedule deviation, cost variance, and productivity. Usually measures-

• Number of software developer

• Staffing patterns over the life cycle of software

• Cost and schedule

• Productivity
Advantages of Software Metrics :
1.Reduction in cost or budget.
2.It helps to identify the particular area for improvising.
3.It helps to increase the product quality.
4.Managing the workloads and teams.
5.Reduction in overall time to produce the product,.
6.It helps to determine the complexity of the code and to test the code with resources.
7.It helps in providing effective planning, controlling and managing of the entire product.
Disadvantages of Software Metrics :
8.It is expensive and difficult to implement the metrics in some cases.
2.Performance of the entire team or an individual from the team can’t be determined. Only the
performance of the product is determined.
3.Sometimes the quality of the product is not met with the expectation.
4.It leads to measure the unwanted data which is wastage of time.
5.Measuring the incorrect data leads to make wrong decision making.
Project Monitoring and Control
• Monitoring and Controlling are processes needed to track, review, and
regulate the progress and performance of the project.
• It also identifies any areas where changes to the project management
method are required and initiates the required changes.
CONT…
• Monitor and control project work: The generic step under which all other
monitoring and controlling activities fall under.
• Perform integrated change control: The functions involved in making
changes to the project plan. When changes to the schedule, cost, or any
other area of the project management plan are necessary, the program is
changed and re-approved by the project sponsor.
• Validate scope: The activities involved with gaining approval of the
project's deliverables.
• Control scope: Ensuring that the scope of the project does not change and
that unauthorized activities are not performed as part of the plan (scope
creep).
• Control schedule: The functions involved with ensuring the project work is
performed according to the schedule, and that project deadlines are met.
CONT…
• Control costs: The tasks involved with ensuring the project costs stay
within the approved budget.
• Control quality: Ensuring that the quality of the projects.,deliverables
is to the standard defined in the project management plan.
• Control communications: Providing for the communication needs of
each project stakeholder.
• Control Risks: Safeguarding the project from unexpected events that
negatively impact the project's budget, schedule, stakeholder needs,
or any other project success criteria.
• Control procurements: Ensuring the project's subcontractors and
vendors meet the project goals.
• Control stakeholder engagement: The tasks involved with ensuring
that all of the project's stakeholders are left satisfied with the project
 Software Life Cycle Models
The goal of Software Engineering is to provide models and processes that lead to
the production of well-documented maintainable software in a manner that is
predictable.
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.

2
Software Life Cycle Models

“The period of time that starts when a software

product is conceived and ends when the
product is no longer available for use. The
software life cycle typically includes a
requirement phase, design phase,
implementation phase, test phase, installation
and check out phase, operation and
maintenance phase, and sometimes retirement
phase”.
Stages of the Software Development Life
Cycle Model
What are the main phases of SDLC?
• The main phases of SDLC include Requirements, Design,
Implementation (Coding), Testing, Deployment, and Maintenance.
These phases represent the stages a software project goes through
from initiation to completion.
Software Development Life Cycle Models
 Build & Fix Model

❖ Product is constructed without

specifications or any attempt at
design
Build
❖ Adhoc approach and not
Code
well defined

❖ Simple two phase model Fix

Build & Fix Model

❖ Suitable for small programming exercises of 100 or 200 lines

❖ Unsatisfactory for software for any reasonable size

❖ Code soon becomes unfixable & unenhanceable

❖ No room for structured design

❖ Maintenance is practically not possible

5
Waterfall Model
• Winston Royce introduced the Waterfall Model in 1970.
• This model has five phases: Requirements analysis and specification,
design, implementation and unit testing, integration and system
testing, and operation and maintenance.
• The steps always follow in this order and do not overlap.
• The developer must complete every phase before the next phase
begins.
• This model is named "Waterfall Model", because its diagrammatic
representation resembles a cascade of waterfalls.
• Requirements analysis and specification phase:
The aim of this phase is to understand the exact requirements of the customer and to
document them properly.
Both the customer and the software developer work together so as to document all the
functions, performance, and interfacing requirement of the software. It describes the
"what" of the system to be produced and not "how.“
In this phase, a large document called Software Requirement Specification (SRS) document
is created which contained a detailed description of what the system will do in the common
language.
• Design Phase: This phase aims to transform the requirements gathered in the SRS into a
suitable form which permits further coding in a programming language. It defines the
overall software architecture together with high level and detailed design. All this work is
documented as a Software Design Document (SDD).
• Implementation and unit testing: During this phase, design is implemented. If the SDD is
complete, the implementation or coding phase proceeds smoothly, because all the
information needed by software developers is contained in the SDD.
• During testing, the code is thoroughly examined and modified. Small modules are tested in
isolation initially. After that these modules are tested by writing some overhead code to
check the interaction between these modules and the flow of intermediate output.
• Integration and System Testing: This phase is highly crucial as the
quality of the end product is determined by the effectiveness of the
testing carried out.
The better output will lead to satisfied customers, lower
maintenance costs, and accurate results.
Unit testing determines the efficiency of individual modules.
However, in this phase, the modules are tested for their interactions
with each other and with the system.
• Operation and maintenance phase: Maintenance is the task
performed by every user once the software has been delivered to the
customer, installed, and operational.
When to use SDLC Waterfall Model?

• When the requirements are constant and not changed regularly.

• A project is short
• The situation is calm
• Where the tools and technology used is consistent and is not
changing
• When resources are well prepared and are available to use.
Advantages of Waterfall model
• This model is simple to implement also the number of resources that are required for it
is minimal.
• The requirements are simple and explicitly declared; they remain unchanged during the
entire project development.
• The start and end points for each phase is fixed, which makes it easy to cover progress.
• The release date for the complete product, as well as its final cost, can be determined
before development.
• It gives easy to control and clarity for the customer due to a strict reporting system.
Disadvantages of Waterfall model
• In this model, the risk factor is higher, so this model is not suitable for more significant
and complex projects.
• This model cannot accept the changes in requirements during development.
• It becomes tough to go back to the phase. For example, if the application has now
shifted to the coding phase, and there is a change in requirement, It becomes tough to
go back and change it.
• Since the testing done at a later stage, it does not allow identifying the challenges and
risks in the earlier phase, so the risk reduction strategy is difficult to prepare.
 Waterfall Model

Requirement This model is named

Analysis & Specification
model” because its
“waterfall
representation resembles a cascade
diagrammatic
Design waterfalls.
of

Implementatio
n and unit
testing
Integr ation
and system
testing

Operation
and
maintenance
 Waterfall Model

This model is easy to understand and reinforces

the notion of “define before design” and “design
before code”.

The model expects complete & accurate

requirements early in the process, which is unrealistic
Waterfall Model

Problems of waterfall model

i. It is difficult to define all requirements at the beginning of a
project
ii. This model is not suitable for accommodating any change
iii. A working version of the system is not seen until late in
the project’s life

iv. It does not scale up well to large projects.

v. Real projects are rarely sequential.

 Prototype Model
• The prototype model requires that before carrying out the development
of actual software, a working prototype of the system should be built. A
prototype is a toy implementation of the system.
OR
Prototyping is defined as the process of developing a working replication
of a product or system that has to be engineered.
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.
difference between
original and prototype
Prototype Model
Steps of Prototype Model

1.Requirement Gathering and Analyst

2.Quick Decision

3.Build a Prototype

4.Assessment or User Evaluation

5.Prototype Refinement

6.Engineer Product
• 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 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
strength 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.
•Advantage of Prototype Model
•Reduce the risk of incorrect user requirement
•Regular visible process aids management
•Support early product marketing
•Reduce Maintenance cost.
•Errors can be detected much earlier as the system is made side by side.

•Disadvantage of Prototype Model

•An unstable/badly implemented prototype often becomes the final product.
•Require extensive customer collaboration
• Costs customer money
• Needs committed customer
• Difficult to finish if customer withdraw
• May be too customer specific, no broad market
•Difficult to know how long the project will last.
•Prototyping tools are expensive.
•Special tools & techniques are required to build a prototype.
•It is a time-consuming process.
Incremental Process Models
They are effective in the situations where requirements are defined
precisely and there is no confusion about the functionality of the final
product.

After every cycle a useable product is given to the customer.

Popular particularly when we have to quickly deliver a limited functionality

system.

A, B, and C are modules of

Software Products that are
incrementally developed and
delivered.
Incremental Model
• Incremental Model is a process of software development where
requirements divided into multiple standalone modules of the software
development cycle. In this model, each module goes through the
requirements, design, implementation and testing phases.

• Every subsequent release of the module adds function to the previous

release. The process continues until the complete system achieved.
• 1. Requirement analysis: In the first phase of the incremental model, the
product analysis expertise identifies the requirements. And the system
functional requirements are understood by the requirement analysis team. To
develop the software under the incremental model, this phase performs a
crucial role.
• 2. Design & Development: In this phase of the Incremental model of SDLC, the
design of the system functionality and the development method are finished
with success. When software develops new practicality, the incremental model
uses style and development phase.
• 3. Testing: In the incremental model, the testing phase checks the performance
of each existing function as well as additional functionality. In the testing phase,
the various methods are used to test the behavior of each task.
• 4. Implementation: Implementation phase enables the coding phase of the
development system. It involves the final coding that design in the designing and
development phase and tests the functionality in the testing phase. After
completion of this phase, the number of the product working is enhanced and
upgraded up to the final system product
CONT…
Types of Incremental Model
• 1. Staged Delivery Model
2. Parallel Development Model
Advantages of Incremental Process Model
1.Prepares the software fast.
2.Clients have a clear idea of the project.
3.Changes are easy to implement.
4.Provides risk handling support, because of its iterations.
5.Adjusting the criteria and scope is flexible and less costly.
6.Comparing this model to others, it is less expensive.
7.The identification of errors is simple.

Disadvantages of Incremental Process Model

8.A good team and proper planned execution are required.
2.Because of its continuous iterations the cost increases.
3.Issues may arise from the system design if all needs are not gathered upfront throughout the
duration of the program lifecycle.
4.Every iteration step is distinct and does not flow into the next.
5.It takes a lot of time and effort to fix an issue in one unit if it needs to be corrected in all the
units.
Iterative Model
• In this Model, you can start with some of the software specifications
and develop the first version of the software.
• After the first version if there is a need to change the software, then
a new version of the software is created with a new iteration.
• Every release of the Iterative Model finishes in an exact and fixed
period that is called iteration.
• The Iterative Model allows the accessing earlier phases, in which the
variations made respectively.
• The final output of the project renewed at the end of the Software
Development Life Cycle (SDLC) process.
• 1. Requirement gathering & analysis: In this phase, requirements are
gathered from customers and check by an analyst whether
requirements will fulfil or not. Analyst checks that need will achieve
within budget or not. After all of this, the software team skips to the
next phase.
• 2. Design: In the design phase, team design the software by the
different diagrams like Data Flow diagram, activity diagram, class
diagram, state transition diagram, etc.
• 3. Implementation: In the implementation, requirements are written
in the coding language and transformed into computer programmes
which are called Software.
• 4. Testing: After completing the coding phase, software testing starts
using different test methods. There are many test methods, but the
most common are white box, black box, and grey box test methods.
• 5. Deployment: After completing all the phases, software is deployed
to its work environment.
• 6. Review: In this phase, after the product deployment, review phase
is performed to check the behaviour and validity of the developed
product. And if there are any error found then the process starts again
from the requirement gathering.
• 7. Maintenance: In the maintenance phase, after deployment of the
software in the working environment there may be some bugs, some
errors or new updates are required. Maintenance involves debugging
and new addition options.
• When to use the Iterative Model?
• When requirements are defined clearly and easy to
understand.
• When the software application is large.
• When there is a requirement of changes in future.
Advantage(Pros) of Iterative Model:
• Testing and debugging during smaller iteration is easy.
• A Parallel development can plan.
• It is easily acceptable to ever-changing needs of the project.
• Risks are identified and resolved during iteration.
• Limited time spent on documentation and extra time on designing.
Disadvantage(Cons) of Iterative Model:
• It is not suitable for smaller projects.
• More Resources may be required.
• Design can be changed again and again because of imperfect
requirements.
• Requirement changes can cause over budget.
• Project completion date not confirmed because of changing
requirements.
Iterative Enhancement Model
This model has the same phases as the waterfall model, but with
fewer restrictions. Generally the phases occur in the same order as in
the waterfall model, but they may be conducted in several cycles.
Useable product is released at the end of the each cycle, with each
release providing additional functionality.

✓ Customers and developers specify as many requirements as

possible and prepare a SRS document.
✓ Developers and customers then prioritize these requirements
✓ Developers implement the specified requirements in one or
more cycles of design, implementation and test based on the
defined priorities.
 Iterative Enhancement Model

Requirements
specification

Architectural
design

Detailed
design

Implementation
and unit testing

Integration
and
testing

Operation and
Maintenance
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.
 Spiral Model
Models do not deal with uncertainly which is inherent to software projects.
Important software projects have failed because project risks were
neglected & nobody was prepared when something unforeseen happened.

Barry Boehm recognized this and tired to incorporate the “project risk”
factor into a life cycle model.

The result is the spiral model, which was presented in 1986.

The Spiral Model
• The Spiral Model is a Software Development Life Cycle (SDLC) model that
provides a systematic and iterative approach to software development.
• In its diagrammatic representation, looks like a spiral with many loops.
• The exact number of loops of the spiral is unknown and can vary from project
to project.
• Each loop of the spiral is called a Phase of the software development process.
• The exact number of phases needed to develop the product can be varied by
the project manager depending upon the project risks.
• 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.
• 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.
Spiral Model
 Spiral Model
The radial dimension of the model represents the cumulative costs.
Each path around the spiral is indicative of increased costs. The
angular dimension represents the progress made in completing
each cycle. Each loop of the spiral from X-axis clockwise through
360o represents one phase. One phase is split roughly into four
sectors of major activities.
▪ Planning: Determination of objectives,
alternatives & constraints.
▪ Risk Analysis: Analyze alternatives and attempts to
identify and resolve the risks involved.
▪ Development: Product development and testing product.
▪ Assessment: Customer evaluation
• 1. Planning: The first phase of the Spiral Model is the planning phase, where
the scope of the project is determined and a plan is created for the next
iteration of the spiral.
• 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
 Spiral Model
▪ An important feature of the spiral model is that each phase is
completed with a review by the people concerned with the
project (designers and programmers)
▪ The advantage of this model is the wide range of options to
accommodate the good features of other life cycle models.
▪ It becomes equivalent to another life cycle
appropriate
model in situations.
The spiral model has some difficulties that need to be resolved
before it can be a universally applied life cycle model. These
difficulties include lack of explicit process guidance in
determiningconstraints, alternatives; relying on risk assessment
objectives,
expertise; and provides more flexibility than required for many
applications.
When to use Spiral Model?
•When deliverance is required to be frequent.
•When the project is large
•When requirements are unclear and complex
•When changes may require at any time
•Large and high budget projects
Advantages
•High amount of risk analysis
•Useful for large and mission-critical projects.

Disadvantages
•Can be a costly model to use.
•Risk analysis needed highly particular expertise
•Doesn't work well for smaller projects.
 Agile Model
The agile model was mainly designed to adapt to changing requests
quickly.
The main goal of the Agile model is to facilitate quick project completion.
The agile model refers to a group of development processes.
These processes have some similar characteristics but also possess certain
subtle differences among themselves.

The Agile Model is an incremental and iterative process of software development. It

defines each iteration’s number, duration, and scope in advance.
Phases of Agile Model:

Following are the phases in the Agile model are as follows:

1.Requirements gathering
2.Design the requirements
3.Construction/ iteration
4.Testing/ Quality assurance
5.Deployment
6.Feedback
• 1. Requirements gathering: In this phase, you must define the
requirements. You should explain business opportunities and plan the
time and effort needed to build the project. Based on this
information, you can evaluate technical and economic feasibility.

• 2. Design the requirements: When you have identified the project,

work with stakeholders to define requirements. You can use the user
flow diagram or the high-level UML diagram to show the work of new
features and show how it will apply to your existing system.

• 3. Construction/ iteration: When the team defines the requirements,

the work begins. Designers and developers start working on their
project, which aims to deploy a working product. The product will
undergo various stages of improvement, so it includes simple,
minimal functionality.
• 4. Testing: In this phase, the Quality Assurance team examines the
product's performance and looks for the bug.

• 5. Deployment: In this phase, the team issues a product for the user's
work environment.

• 6. Feedback: After releasing the product, the last step is feedback. In

this, the team receives feedback about the product and works
through the feedback.
When to use the Agile Model?
•When frequent changes are required.
•When a highly qualified and experienced team is
available.
•When a customer is ready to have a meeting with a
software team all the time.
•When project size is small.
• Advantage(Pros) of Agile Method:
• Frequent Delivery
• Face-to-Face Communication with clients.
• Efficient design and fulfils the business requirement.
• Anytime changes are acceptable.
• It reduces total development time.
• Disadvantages(Cons) of Agile Model:
• Due to the shortage of formal documents, it creates confusion and
crucial decisions taken throughout various phases can be
misinterpreted at any time by different team members.
• Due to the lack of proper documentation, once the project completes
and the developers allotted to another project, maintenance of the
finished project can become a difficulty