The term software engineering is composed of two words, software

and engineering

What is Software?
“ Software is a set of instructions to acquire inputs and to manipulate them to produce the
desired output in terms of functions and performance as determined by the user of the
software. It also include a set of documents, such as the software manual , meant for users
to understand the software system.”
OR
Software is more than just a program code. A program is an executable code, which
serves some computational purpose. Software is considered to be a collection of
executable programming code, associated libraries and documentations. Software, when
made for a specific requirement is called software product.
Classes of Software:
Software is classified into two classes:
1. Generic Software:
designed for broad customer market whose requirements are very
common, fairly stable and well understood by the software engineer.
2. Customized Software:
is developed for a customer where domain , environment and
requirements are being unique to that customer and cannot be satisfied
by generic products.
 What is Good Software?

Software has number of attributes which decide whether it is a

good or bad . The definition of a good software changes with the
person who evaluates it. The software is required by the customer ,
used by the end users of an organization and developed by
software engineer . Each one will evaluate the different attributes
differently in order to decide whether the software is good.
 What are the attributes of good software?

The software should deliver the required functionality and

performance to the user and should be maintainable, dependable and
usable.
Maintainability – Software must change to meet changing needs
Dependability – Software must be trustworthy
Efficiency – Software should not make wasteful use of system
resources
Usability – Software must be usable by the users for which it was
designed
 Software - Characteristics
▪ Software has a dual role. It is a product, but also a vehicle for
delivering a product.
▪ Software is a logical rather than a physical system element.
▪ Software has characteristics that differ considerably from those
of hardware.
▪ Software is developed or engineered, it is not manufactured in
the classical sense.
▪ Software doesn’t “wear out”.
▪ Most software is custom-built, rather than being assembled from
existing components.
 Types of Software
• System Software- A collection of programs written to service other programs at system
level. For example, compiler, operating systems.
• Real-time Software- Programs that monitor/analyze/control real world events as they
occur.
• Business Software- Programs that access, analyze and process business information.
• Engineering and Scientific Software - Software using “number crunching” algorithms
for different science and applications. System simulation, computer-aided design.

• Embedded Software-: Embedded software resides in read-only memory and is used

to control products and systems for the consumer and industrial markets. It has very
limited and esoteric functions and control capability.
• Artificial Intelligence (AI) Software: Programs make use of AI techniques and
methods to solve complex problems. Active areas are expert systems, pattern
recognition, games
 Engineering on the other hand, is all about developing products,
using well-defined, scientific principles and methods
Software Engineering
“A systematic approach to the analysis, design, implementation and maintenance
of software.” (The Free On-Line Dictionary of Computing)
“ The systematic application of tools and techniques in the development of
computer-based applications.” (Sue Conger in The New Software Engineering)
“ Software Engineering is about designing and developing highquality
software.” (Shari Lawrence Pfleeger in Software Engineering -- The Production
of Quality Software)
So, we can define software engineering as an engineering branch associated
with the development of software product using well-defined scientific
principles, methods and procedures. The outcome of software engineering is an
efficient and reliable software product.
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.
 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
 Why Software Engineering?

Major Goals:
- To increase software productivity and quality.
- To effectively control software schedule and planning.
- To reduce the cost of software development.
- To meet the customers’ needs and requirements.
- To enhance the conduction of software engineering process.
- To improve the current software engineering practice.
- To support the engineers’ activities in a systematic and
efficient manner.
 Difference between Software Engineering process and
Conventional Engineering Process

1. 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.
2. Conventional Engineering Process :
It is a engineering process which is highly based on empirical knowledge and is
about building cars, machines and hardware.
 Difference between Software Engineering Process and Conventional
Engineering Process :

S.No. Software Engineering Process Conventional Engineering Process

Software Engineering Process is a process
Conventional Engineering Process is a process which
which majorly involves computer science,
1. majorly involves science, mathematics and empirical
information technology and discrete
knowledge.
mathematics.
It is mainly related with computers,
It is about building cars, machines, hardware, buildings
2. programming and writing codes for
etc.
building applications.
In Software Engineering Process In Conventional Engineering Process construction and
3.
construction and development cost is low. development cost is high.
It can involve the application of new and It usually applies only known and tested principles to
4.
untested elements in software projects. meet product requirements.
In Software Engineering Process, most
In Conventional Engineering Process, most development
5. development effort goes into building new
efforts are required to change old designs.
designs and features.
6. It majorly emphasize on quality. It majorly emphasize on mass production.
 Program vs. Software
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:

Programs

Documentations
Operating
Process

Software = Programs + Documentations + Operating Procedures

 List of Documentations Manuals
1. Program: Program is a
combination of source Formal
code & object code. Analysis/ Specification
Context Diagram
2. Documentation: Docu Specification
Data Flow
mentation consists of Diagram
different types of Flowchart
manuals. Examples of Design
documentation Documentation
E-R Diagram
Manual
manuals are: Data
Flow Diagram, Flow Source Code
Listings
Charts, ER diagrams, Implementation
etc. Cross-
Test Reference
Data Listing
Design Test
Results
3. Operating Procedures: Operating List of operating Procedure Manuals
Procedures consist of instructions to set up
and use the software system and
instructions on how react to the system System Overview
failure. Example of operating system Operating
procedures manuals is: installation guide, Manuals Reference Material
Beginner's guide, reference guide, system
administration guide, etc. Beginner’s Guide

Operating
Procedures

System Administration
Guide
Operating
Manuals
Installation Guide
 Software Processes

The term software specifies to the set of computer programs, procedures and associated
documents (Flowcharts, manuals, etc.) that describe the program and how they are to be used.
A software process is the set of activities and associated outcome that produce a software
product. Software engineers mostly carry out these activities. These are four key process
activities, which are common to all software processes. These activities are:
1.Software specifications: The functionality of the software and constraints on its operation
must be defined.
2.Software development: The software to meet the requirement must be produced.
3.Software validation: The software must be validated to ensure that it does what the
customer wants.
4.Software evolution: The software must evolve to meet changing client needs.
 The Software Process Model

A software process model is a specified definition of a software process, which is presented from a particular perspective.
Models, by their nature, are a simplification, so a software process model is an abstraction of the actual process, which is
being described. Process models may contain activities, which are part of the software process, software product, and the
roles of people involved in software engineering. Some examples of the types of software process models that may be
produced are:
1.A workflow model: This shows the series of activities in the process along with their inputs, outputs and dependencies.
The activities in this model perform human actions.
2.A dataflow or activity model: This represents the process as a set of activities, each of which carries out some data
transformations. It shows how the input to the process, such as a specification is converted to an output such as a design.
The activities here may be at a lower level than activities in a workflow model. They may perform transformations carried
out by people or by computers.
3.A role/action model: This means the roles of the people involved in the software process and the activities for which
they are responsible.
 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 .
software crisis was due to using same workforce, same methods, same tools even though
rapidly increasing in software demand, complexity of software and software challenges.
With increase in the complexity of software, many software problems arise because
existing methods were insufficient.
If we will use same workforce, same methods and same tools after fast increasing in
software demand, software complexity and software challenges, then there arise some
problems like software budget problem, software efficiency problem, software quality
problem, software managing and delivering problem etc. This condition is called software
crisis.
 Software Crisis

1.Size: Software is becoming more expensive and more complex with the growing
complexity and expectation out of software. For example, the code in the consumer
product is doubling every couple of years.
2.Quality: Many software products have poor quality, i.e., the software products defects
after putting into use due to ineffective testing technique. For example,
Software testing typically finds 25 errors per 1000 lines of code.
3.Cost: Software development is costly i.e. in terms of time taken to develop and the
money involved. For example, Development of the FAA's Advanced Automation
System cost over $700 per lines of code.
4.Delayed Delivery: Serious schedule overruns are common. Very often the software
takes longer than the estimated time to develop, which in turn leads
to cost shooting up. For example, one in four large-scale
development projects is never completed.
Causes of Software Crisis:
•The cost of owning and maintaining software was as expensive as developing
the software
•At that time Projects was running over-time
•At that time Software was very inefficient
•The quality of software was low quality
•Software often did not meet requirements
•The average software project overshoots its schedule by half
•At that time Software was never delivered
Solution of Software Crisis:
There is no single solution to the crisis.one possible solution of
software crisis is Software Engineering because software engineering
is a systematic, disciplined and quantifiable approach. For preventing
software crisis, there are some guidelines:
•Reduction in software over-budget
•The quality of software must be high
•Less time needed for software project
•Experience working team member on software project
•Software must be delivered
 Software Quality Attributes in Software Architecture
1). Usability: is one of the most essential attributes, because, unlike in cases with other attributes, users can see
directly how well this attribute of the system is worked out. One of the critical problems of usability is too much
interaction or too many actions necessary to accomplish a task. Incorrect sequences of steps in multistage
interfaces are also a problem of usability. Data elements and controls may be designed not according to the
accepted patterns of user experience, which also complicates the interaction.
Examples of important indicators for this attribute are:
•List of supported devices, OS versions, screen resolutions, and browsers and their versions.
•Elements that accelerate user interaction, such as “hotkeys,” “lists of suggestions,” and so on.
•The average time a user needs to perform individual actions.
•Support of accessibility for people with disabilities.

2) Reliability
Reliability is an attribute of the system responsible for the ability to continue to operate under predefined conditions. Most
often, the system fails due to the inaccessibility of external elements, such as databases, systems, and network connections.
 Software Quality Attributes in Software Architecture
You have to do prioritize these system quality attributes based on your project needs.

3) Availability
Availability is part of reliability and is expressed as the ratio of the available system time to the total working
time. Important indicators for this attribute are:
• Availability.
• Planned downtime.
• The time needed to update the software, and so on.

4) Portability
It is the ability of a software application to run on numerous platforms such as data portability, hosting,
viewing, etc.,
 5) Testability shows how well the system allows performing tests, according to predefined criteria. In
addition to testing performance, testability makes it possible to effectively divide the system into
subsystems.
The main indicators for this attribute are:
•Percentage of coverage with modular, integration, or unit tests.
•The final list of required test environments as well as the final list of used approaches to testing
(manual/automatic, regression, integration, etc.).

6).Scalability is the ability of the system to handle load increases without decreasing performance, or the
possibility to rapidly increase the load.
There are two ways to improve scalability:
•Vertical: To increase, we add more resources, such as memory, disks, or processors into one system.
•Horizontal: We increase the number of computing units and divide the load.
The key indicators for measuring this attribute are:
•If the system allows for horizontal scaling.
•The time needed to increase scaling, in seconds.
•Scaling limitations: the number of servers or the network capacity.
•Possibility to scale: the increase in the number of transactions or the amount of content.
7. Performance : shows the response of the system to performing certain actions for a certain period.
There are two ways how to measure performance:
•Latency: Time spent on responding to an event
•Channel capacity. The number of events that occur at a certain point in time.
In practice, the possible performance indicators include, for example:
•Average/maximum number of system users per time unit.
•Average page load time.
•Average method execution time.
8. Interoperability: is an attribute of the system or part of the system that is responsible for its operation
and the transmission of data and its exchange with other external systems. A well-designed system
facilitates integration with third-party systems. To improve the interoperability, you can use well-designed
external interfaces, standardization systems, etc.
9. Security: is responsible for the ability of the system to reduce the likelihood of malicious or accidental
actions as well as the possibility of theft or loss of information. Several measures are used to protect systems:
authentication, encryption, audit, and others.
Examples of this attribute in the work of the system are:
•Restrictions of user access by authentication/authorization.
•Prevention of SQL injection.
•Encryption of passwords and content.
•Secure connection.
10. Maintainability: is the ability of the system to support changes. Changes can be related to new business
requirements or the correction of old errors and affect system components or separate methods. Also,
maintainability affects the time needed to restore the system after a failure. Excessive dependencies between
components have a very negative effect on maintainability

11. Reusability: is a chance of using a component or system in other components/systems with small or no change.
Segregation of responsibilities, modularization, decreasing of copy-paste are all about reusability. Copying code, or
worse, using different components for the same result in different modules, is one of the biggest problems of
reusability.

12. Supportability: is the ability of the system to provide useful information for identifying and solving problems.
The main issues in ensuring supportability can be addressed with the following means:
•No diagnosis: How the activity and performance of the system are controlled. It includes various types of
logging.
•No tools for troubleshooting: This includes backups, various systems for creating snapshots of the system,
and tools for auditing the system. When the system fails, it is always more pleasant to wait for an automatic
restart than to solve the issue manually.
•No health checking: This includes a variety of systems for measuring compilation time, deployment time,
database size, or mobile application size.
 Software Development Life Cycle
SDLC is a systematic process for building software that ensures the quality and correctness of the software built.
SDLC process aims to produce high-quality software that meets customer expectations. The system development
should be complete in the pre-defined time frame and cost. SDLC consists of a detailed plan which explains how
to plan, build, and maintain specific software. Every phase of the SDLC life Cycle has its own process and
deliverables that feed into the next phase. SDLC stands for Software Development Life Cycle and is also referred
to as the Application
Why SDLC?
Here, are prime reasons why SDLC is important for developing a software system.
•It offers a basis for project planning, scheduling, and estimating
•Provides a framework for a standard set of activities and deliverables
•It is a mechanism for project tracking and control
•Increases visibility of project planning to all involved stakeholders of the development process
•Increased and enhance development speed
•Improved client relations
•Helps you to decrease project risk and project management plan overhead
 SDLC Phases
The entire SDLC process divided into the following stages:

•Phase 1: Requirement collection and analysis (Planning)

•Phase 2: Feasibility study: (Requirements)
•Phase 3: Design:
•Phase 4: Coding: (Software Development)
•Phase 5: Testing:
•Phase 6: Installation/Deployment:
•Phase 7: Maintenance:

Requirement Feasibility
Analysis Study Design Coding Testing Install Deploy Maintenance
Phase 1: Requirement collection and analysis:
The requirement is the first stage in the SDLC process. It is conducted by the senior team members with inputs
from all the stakeholders and domain experts in the industry. Planning for the quality assurance requirements and
recognization of the risks involved is also done at this stage.
This stage gives a clearer picture of the scope of the entire project and the anticipated issues, opportunities, and
directives which triggered the project.

Phase 2: Feasibility study:

Once the requirement analysis phase is completed the next sdlc step is to define and document software needs.
This process conducted with the help of 'Software Requirement Specification' document also known as 'SRS'
document. It includes everything which should be designed and developed during the project life cycle.
There are mainly five types of feasibilities checks:
•Economic: Can we complete the project within the budget or not?
•Legal: Can we handle this project as cyber law and other regulatory framework/compliances.
•Operation feasibility: Can we create operations which is expected by the client?
•Technical: Need to check whether the current computer system can support the software
•Schedule: Decide that the project can be completed within the given schedule or not.
Phase 3: Design:
In this third phase, the system and software design documents are prepared as per the requirement specification
document. This helps define overall system architecture.
This design phase serves as input for the next phase of the model.
There are two kinds of design documents developed in this phase:
High-Level Design (HLD)
• Brief description and name of each module
• An outline about the functionality of every module
• Interface relationship and dependencies between modules
• Database tables identified along with their key elements
• Complete architecture diagrams along with technology details
Low-Level Design(LLD)
• Functional logic of the modules
• Database tables, which include type and size
• Complete detail of the interface
• Addresses all types of dependency issues
• Listing of error messages
• Complete input and outputs for every module
Phase 4: Coding:
Once the system design phase is over, the next phase is coding. In this phase, developers start build the entire
system by writing code using the chosen programming language. In the coding phase, tasks are divided into units or
modules and assigned to the various developers. It is the longest phase of the Software Development Life Cycle
process.
In this phase, Developer needs to follow certain predefined coding guidelines. They also need to use programming
tools like compiler, interpreters, debugger to generate and implement the code.
Phase 5: Testing:
Once the software is complete, and it is deployed in the testing environment. The testing team starts testing the
functionality of the entire system. This is done to verify that the entire application works according to the customer
requirement.
During this phase, QA and testing team may find some bugs/defects which they communicate to developers. The
development team fixes the bug and send back to QA for a re-test. This process continues until the software is bug-
free, stable, and working according to the business needs of that system.

Phase 6: Installation/Deployment:
Once the software testing phase is over and no bugs or errors left in the system then the final deployment process
starts. Based on the feedback given by the project manager, the final software is released and checked for
deployment issues if any.
Phase 7: Maintenance:
Once the system is deployed, and customers start using the developed system, following 3 activities occur
•Bug fixing - bugs are reported because of some scenarios which are not tested at all
•Upgrade - Upgrading the application to the newer versions of the Software
•Enhancement - Adding some new features into the existing software
The main focus of this SDLC phase is to ensure that needs continue to be met and that the system continues to
perform as per the specification mentioned in the first phase.
 Requirement Analysis
What is The
Feasibility Study
Waterfall Model?
Software Design
Software
• WATERFALL MODEL is a Implementation
sequential model that divides
software development into pre- Software Testing
defined phases. Each phase Software
must be completed before the Development
next phase can begin with no Software
overlap between the phases. Maintenance
Each phase is designed for
performing specific activity
during the SDLC phase. It was
introduced in 1970 by Winston
Royce.
 Different Phases of Waterfall Model in Software Engineering

Different phases Activities performed in each stage

Requirement Gathering •During this phase, detailed requirements of the software system to be developed are
stage gathered from client

Design Stage •Plan the programming language, for Example Java, PHP, .net
•or database like Oracle, MySQL, etc.
•Or other high-level technical details of the project

Built Stage •After design stage, it is built stage, that is nothing but coding the software

Test Stage •In this phase, you test the software to verify that it is built as per the specifications
given by the client.

Deployment stage •Deploy the application in the respective environment

Maintenance stage •Once your system is ready to use, you may later require change the code as per
customer request
 When to use SDLC Waterfall Model
Waterfall model can be used
•When Requirements are not changing frequently
•Application is not complicated and big
•Project is short
•Requirement is clear
•Environment is stable
•Technology and tools used are not dynamic and is stable
•Resources are available and trained
 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.
Development moves from concept, through design, implementation, testing, installation,
troubleshooting, and ends up at operation and maintenance. Each phase of development
proceeds in strict order.
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.
 Iterative Model
• An iterative life cycle model does not attempt to start with a full specification
of requirements. Instead, development begins by specifying and implementing
just part of the software, which can then be reviewed in order to identify further
requirements. This process is then repeated, producing a new version of the
software for each cycle of the model.

OR

The iterative process model is the implementation of the software development life cycle in
which the initial development is started based on the initial requirements and more features
are added to the base software product with the ongoing iterations until the final system is
created.
• The Iterative Model allows the
accessing earlier phases, in which the
variations made respectively. The final Feasibility Study
output of the project renewed at the end
of the Software Development Life Cycle Requirement Analysis
(SDLC) process. and Specification

Design
The various phases of Iterative model
Coding and unit
are as follows:
testing
1. Requirement gathering &
analysis: In this phase, requirements are Integration and
gathered from customers and check by an system testing
analyst whether requirements will fulfil or Deployment
not. Analyst checks that need will achieve
within budget or not. After all of this, the
software team skips to the next phase. Maintenance
2. Design: In the design phase, team design
the software by the different diagrams like
Data Flow diagram, activity diagram, class
diagram, state transition diagram, etc.
3. Implementation: In the implementation, requirements are written in the coding language and transformed into computer
programmes which are called Software.
4. Testing: After completing the coding phase, software testing starts using different test methods. There are many test
methods, but the most common are white box, black box, and grey box test methods.
5. Deployment: After completing all the phases, software is deployed to its work environment.
6. Review: In this phase, after the product deployment, review phase is performed to check the behaviour and validity of the
developed product. And if there are any error found then the process starts again from the requirement gathering.
7. Maintenance: In the maintenance phase, after deployment of the software in the working environment there may be some
bugs, some errors or new updates are required. Maintenance involves debugging and new addition options.

When to use the Iterative Model?

1.When requirements are defined clearly and easy to understand.
2.When the software application is large.
3.When there is a requirement of changes in future.

Advantage(Pros) of Iterative Model:

1.Testing and debugging during smaller iteration is easy.
2.A Parallel development can plan.
3.It is easily acceptable to ever-changing needs of the project.
4.Risks are identified and resolved during iteration.
5.Limited time spent on documentation and extra time on designing.
Disadvantage(Cons) of Iterative Model:
1.It is not suitable for smaller projects.
2.More Resources may be required.
3.Design can be changed again and again because of imperfect requirements.
4.Requirement changes can cause over budget.
5.Project completion date not confirmed because of changing requirements.
 What is Evolutionary Model

Evolutionary model is also referred to as the successive versions model and sometimes as the incremental
model. In Evolutionary model, the software requirement is first broken down into several modules (or functional
units) that can be incrementally constructed and delivered (see Figure ).

V1
V1
V1 V2
V2 V3

In evolutionary development model or evolutionary life cycle model, each of the version (V1, V2, V3) as shown
in the diagram will be released with new functionality or functionalities and added to the previous version(s).
For example, Version V2 will have more functional capability or capabilities as compared to its previous version
V1 but will exhibit less capability in terms of functionality from V3. With the incremental pattern of new version
release, the software product is built over the period of time to exhibit the functionality of fully developed
system.
Important points on Evolutionary model
Given below are some of the important points on software evolutionary model:
•In sdlc evolutionary development model the requirement is broken down into different functional units.
•These functional units can also be referred to as module.
•These modules can be incrementally built and delivered.
•Here at the beginning the core module of the software product is developed.
•New functionality is built, added to existing one and released as new version.
•Each successive version is capable of performing more functions in comparision to its previous versions.

Where the evolutionary model is useful

Evolutionary model is useful in many cases. Two most important cases are mentioned below;
1.It is very useful in a large project where you can easily find a module for step by step implementation. The
evolutionary model is used when the users need to start using the many features instead of waiting for the
complete software.
2.The evolutionary model is also very useful in object-oriented software development because all the
development is divided into different units.
The following are the evolutionary models.
1.The prototyping model
2.the spiral model
3.the concurrent development model
Advantages of Evolutionary Model
There are many advantages of evolutionary model, Some main advantages are mentioned below;
1.The big advantage of the evolutionary model is that the user has checked every stage during the
development and it is helpful in achieving customer confidence.
2.There are fewer chances of errors because all the modules are well seen.
3.It helps to reduce the risk of software projects.
4.It also reduces the cost of development.
5.Minimize serious problems during testing.
Disadvantages of Evolutionary Model
There are many dis-advantages of evolutionary model, Some main advantages are mentioned below;
1.The delivery of full software can be late due to different changes by customers during development.
2.It is difficult to divide the problem into several parts, that would be acceptable to the customer which can
be incrementally implemented and delivered.
 What is Prototyping Model?
Prototyping Model is a software development model in which prototype is built, tested, and reworked until an
acceptable prototype is achieved. It also creates base to produce the final system or software. It works best in
scenarios where the project's requirements are not known in detail. It is an iterative, trial and error method which
takes place between developer and client.

Prototyping Model Phases

 Prototyping Model has following six SDLC phases as follow:

Step 1: Requirements gathering and analysis

A prototyping model starts with requirement analysis. In this phase, the requirements of the system are
defined in detail. During the process, the users of the system are interviewed to know what is their
expectation from the system.
Step 2: Quick design
The second phase is a preliminary design or a quick design. In this stage, a simple design of the system
is created. However, it is not a complete design. It gives a brief idea of the system to the user. The quick
design helps in developing the prototype.
Step 3: Build a Prototype
In this phase, an actual prototype is designed based on the information gathered from quick design. It is a
small working model of the required system.
Step 4: Initial user evaluation
In this stage, the proposed system is presented to the client for an initial evaluation. It helps to find out the
strength and weakness of the working model. Comment and suggestion are collected from the customer
and provided to the developer.
Step 5: Refining prototype
If the user is not happy with the current prototype, you need to refine the prototype according to the user's
feedback and suggestions.
This phase will not over until all the requirements specified by the user are met. Once the user is satisfied
with the developed prototype, a final system is developed based on the approved final prototype.
Step 6: Implement Product and Maintain
Once the final system is developed based on the final prototype, it is thoroughly tested and deployed to
production. The system undergoes routine maintenance for minimizing downtime and prevent large-scale
failures.
 Types of Prototyping Models
Four types of Prototyping models are:
1.Rapid Throwaway prototypes
2.Evolutionary prototype
3.Incremental prototype
4.Extreme prototype
Rapid Throwaway Prototype
Rapid throwaway is based on the preliminary requirement. It is quickly developed to show how the
requirement will look visually. The customer's feedback helps drives changes to the requirement, and the
prototype is again created until the requirement is baselined.
In this method, a developed prototype will be discarded and will not be a part of the ultimately accepted
prototype. This technique is useful for exploring ideas and getting instant feedback for customer requirements.
Evolutionary Prototyping
Here, the prototype developed is incrementally refined based on customer's feedback until it is finally
accepted. It helps you to save time as well as effort. That's because developing a prototype from scratch for
every interaction of the process can sometimes be very frustrating.
This model is helpful for a project which uses a new technology that is not well understood. It is also used
for a complex project where every functionality must be checked once. It is helpful when the requirement
is not stable or not understood clearly at the initial stage.
Incremental Prototyping
In incremental Prototyping, the final product is decimated into different small prototypes and developed
individually. Eventually, the different prototypes are merged into a single product. This method is helpful to
reduce the feedback time between the user and the application development team.
Extreme Prototyping:
Extreme prototyping method is mostly used for web development. It is consists of three sequential phases.
1.Basic prototype with all the existing page is present in the HTML format.
2.You can simulate data process using a prototype services layer.
3.The services are implemented and integrated into the final prototype.
Advantages of the Prototyping Model
Here, are important pros/benefits of using Prototyping models:
•Users are actively involved in development. Therefore, errors can be detected in the initial stage of the software
development process.
•Missing functionality can be identified, which helps to reduce the risk of failure as Prototyping is also
considered as a risk reduction activity.
•Helps team member to communicate effectively
•Customer satisfaction exists because the customer can feel the product at a very early stage.
•There will be hardly any chance of software rejection.
•Quicker user feedback helps you to achieve better software development solutions.
•Allows the client to compare if the software code matches the software specification.
•It also identifies the complex or difficult functions.
•Encourages innovation and flexible designing.
•It is a straightforward model, so it is easy to understand.
•No need for specialized experts to build the model
•The prototype serves as a basis for deriving a system specification.
•The prototype helps to gain a better understanding of the customer's needs.
•Prototypes can be changed and even discarded.
•A prototype also serves as the basis for operational specifications.
•Prototypes may offer early training for future users of the software system.
Disadvantages of the Prototyping Model
Here, are important cons/drawbacks of prototyping model:
•Prototyping is a slow and time taking process.
•The cost of developing a prototype is a total waste as the prototype is ultimately thrown away.
•Prototyping may encourage excessive change requests.
•Some times customers may not be willing to participate in the iteration cycle for the longer time duration.
•There may be far too many variations in software requirements when each time the prototype is evaluated
by the customer.
•Poor documentation because the requirements of the customers are changing.
•It is very difficult for software developers to accommodate all the changes demanded by the clients.
•After seeing an early prototype model, the customers may think that the actual product will be delivered to
him soon.
•The client may lose interest in the final product when he or she is not happy with the initial prototype.
•Developers who want to build prototypes quickly may end up building sub-standard development
solutions.
 What is Spiral Model?

Spiral Model is a risk-driven software development process model. It is a combination of

waterfall model and iterative model. Spiral Model helps to adopt software development
elements of multiple process models for the software project based on unique risk patterns
ensuring efficient development process.
Each phase of spiral model in software engineering begins with a design goal and ends with
the client reviewing the progress. The spiral model in software engineering was first
mentioned by Barry Boehm in his 1986 paper.
The development process in Spiral model in SDLC, starts with a small set of requirement
and goes through each development phase for those set of requirements. The software
engineering team adds functionality for the additional requirement in every-increasing
spirals until the application is ready for the production phase. The below figure very well
explain Spiral Model:
 Spiral Model Phases
Spiral Model Activities performed during phase
Phases

Planning •It includes estimating the cost, schedule and resources for
the iteration. It also involves understanding the system
requirements for continuous communication between the
system analyst and the customer

Risk •Identification of potential risk is done while risk mitigation

Analysis strategy is planned and finalized

Engineering •It includes testing, coding and deploying software at the

customer site

Evaluation •Evaluation of software by the customer. Also, includes

identifying and monitoring risks such as schedule slippage
and cost overrun
 When to use Spiral Model?
•A Spiral model in software engineering is used when project is large
•When releases are required to be frequent, spiral methodology is used
•When creation of a prototype is applicable
•When risk and costs evaluation is important
•Spiral methodology is useful for medium to high-risk projects
•When requirements are unclear and complex, Spiral model in SDLC is useful
•When changes may require at any time
•When long term project commitment is not feasible due to changes in economic priorities
Spiral Model Advantages and Disadvantages
Advantages Disadvantages
•Additional functionality or changes can be done at a later stage •Risk of not meeting the schedule or budget

•Cost estimation becomes easy as the prototype building is done in •Spiral development works best for large projects only also demands
small fragments risk assessment expertise

•Continuous or repeated development helps in risk management •For its smooth operation spiral model protocol needs to be followed
strictly
•Development is fast and features are added in a systematic way in •Documentation is more as it has intermediate phases
Spiral development

•There is always a space for customer feedback •Spiral software development is not advisable for smaller project, it
might cost them a lot