UNIT 1

1 Software Engineering

The term software engineering is the product of two words, software, and engineering. The software is
a collection of integrated programs. Software consists of carefully-organized instructions and code
written by developers on any of various particular computer languages. Computer programs and
related documentation such as requirements, design models and user manuals. Engineering is the
application of scientific and practical knowledge to invent, design, build, maintain, and improve
frameworks, processes, etc.

Software Engineering is an engineering branch related to the evolution of software product using well-
defined scientific principles, techniques, and procedures. The result of software engineering is an
effective and reliable software product.

1.1 Need of Software Engineering

The necessity of software engineering appears because of a higher rate of progress in user
requirements and the environment on which the program is working.
o Huge Programming: It is simpler to manufacture a wall than to a house or building, similarly,
as the measure of programming become extensive engineering has to step to give it a scientific
process.
o Adaptability: If the software procedure were not based on scientific and engineering ideas, it
would be simpler to re-create new software than to scale an existing one.
o Cost: As the hardware industry has demonstrated its skills and huge manufacturing has let
down the cost of computer and electronic hardware. But the cost of programming remains high
if the proper process is not adapted.
o Dynamic Nature: The continually growing and adapting nature of programming hugely
depends upon the environment in which the client works. If the quality of the software is
continually changing, new upgrades need to be done in the existing one.
 o Quality Management: Better procedure of software development provides a better and quality
software product.

 Reduces complexity: Big software is always complicated and challenging to progress.

Software engineering has a great solution to reduce the complication of any project. Software
engineering divides big problems into various small issues. And then start solving each small
issue one by one. All these small problems are solved independently to each other.
 To minimize software cost: Software needs a lot of hard work and software engineers are
highly paid experts. A lot of manpower is required to develop software with a large number of
codes. But in software engineering, programmers project everything and decrease all those
things that are not needed. In turn, the cost for software productions becomes less as compared
to any software that does not use software engineering method.
 To decrease time: Anything that is not made according to the project always wastes time. And
if you are making great software, then you may need to run many codes to get the definitive
running code. This is a very time-consuming procedure, and if it is not well handled, then this
can take a lot of time. So if you are making your software according to the software
engineering method, then it will decrease a lot of time.
 Handling big projects: Big projects are not done in a couple of days, and they need lots of
patience, planning, and management. And to invest six and seven months of any company, it
requires heaps of planning, direction, testing, and maintenance. No one can say that he has
given four months of a company to the task, and the project is still in its first stage. Because the
company has provided many resources to the plan and it should be completed. So to handle a
big project without any problem, the company has to go for a software engineering method.
 Reliable software: Software should be secure, means if you have delivered the software, then
it should work for at least its given time or subscription. And if any bugs come in the software,
the company is responsible for solving all these bugs. Because in software engineering, testing
and maintenance are given, so there is no worry of its reliability.
 Effectiveness: Effectiveness comes if anything has made according to the standards. Software
standards are the big target of companies to make it more effective. So Software becomes more
effective in the act with the help of software engineering.

1.2 Components of Software

There are three components of the software: These are: Program, Documentation, and Operating
Procedures.

 Program –A computer program is a list of instructions that tell a computer what to do.
 Documentation – Source information about the product contained in design documents,
detailed code comments, etc.
 Operating Procedures –Set of step-by-step instructions compiled by an organization to help
workers carry out complex routine operations.
 Code: the instructions that a computer executes in order to perform a specific task or set of
tasks.
 Data: the information that the software uses or manipulates.
  User interface: the means by which the user interacts with the software, such as buttons,
menus, and text fields.
 Libraries: pre-written code that can be reused by the software to perform common tasks.
 Documentation: information that explains how to use and maintain the software, such as user
manuals and technical guides.
 Test cases: a set of inputs, execution conditions, and expected outputs that are used to test the
software for correctness and reliability.
 Configuration files: files that contain settings and parameters that are used to configure the
software to run in a specific environment.
 Build and deployment scripts: scripts or tools that are used to build, package, and deploy the
software to different environments.
 Metadata: information about the software, such as version numbers, authors, and copyright
information.

1.3 Characteristics of software

An engineer’s first consideration when creating any kind of software product is, “What are the
characteristics of a good software product?” Well before we talk about Software characteristics, let’s
look at what one can reasonably expect from any software. First and foremost, a software product
must satisfy the needs of the end-user as well as the business. Additionally, software development and
maintenance should be affordable. Software development should be completed within the specified
time frame.

Categories of Software Characteristics

1. Operational: In operational categories, the factors that decide the software performance in
operations. It can be measured on:

 Budget
 Usability
 Efficiency
 Correctness
 Functionality
 Dependability
 Security
 Safety

2. Transitional: When the software is moved from one platform to another, the factors deciding the
software quality:

 Portability
 Interoperability
 Reusability
  Adaptability

3. Maintenance: In this categories all factors are included that describes about how well a software has
the capabilities to maintain itself in the ever changing environment:

 Modularity
 Maintainability
 Flexibility
 Scalability

Characteristics of Good Software

a. Functionality: The software meets the requirements and specifications that it was designed for,
and it behaves as expected when it is used in its intended environment.
b. Usability: The software is easy to use and understand, and it provides a positive user
experience.
c. Reliability: The software is free of defects and it performs consistently and accurately under
different conditions and scenarios.
d. Performance: The software runs efficiently and quickly, and it can handle large amounts of
data or traffic.
e. Security: The software is protected against unauthorized access and it keeps the data and
functions safe from malicious attacks.
f. Maintainability: The software is easy to change and update, and it is well-documented, so that
it can be understood and modified by other developers.
g. Reusability: The software can be reused in other projects or applications, and it is designed in a
way that promotes code reuse.
h. Scalability: The software can handle an increasing workload and it can be easily extended to
meet the changing requirements.
i. Testability: The software is designed in a way that makes it easy to test and validate, and it has
a comprehensive test coverage.

OR

o Functionality: The functionality of software refers to its ability to perform and function
according to design specifications. In simple terms, software systems should function correctly,
i.e. perform all the functions for which they are designed. The functions refer to the features
that the end user, as well as the business, expect as basic facilities from the system. All these
functions must be integrated into the system. Many software applications out there are
designed for simplicity, but ultimately, the purpose of the software is to provide its users with
the desired functionality. In order to look like the best software product, it must have a clear
appearance, components, and functions. However, there are also those products out there that
can provide a great deal of value for your money.

o Usability (User-friendly): The user-friendliness of the software is characterized by its ease of

use. In other words, learning how to use the software should require less effort or time.
Navigating the software is extremely important since it helps determine the journey the user
 takes within the software. This is imperative to ensure visitors remain on your website and
have a positive experience, which leads to an increase in sales and brand loyalty. An important
indicator of a good piece of software is its user interface, i.e., the smooth flow of its design. A
product with a great UI (User Interface) design is more likely to get noticed than one without.
If a software program isn’t user-friendly, users may have trouble navigating the software and
using some of its features. Software should require less time or effort to learn. Ideally, software
should be easy to use even by people with no IT experience.

o Efficiency: Essentially, it refers to the software’s ability to utilize human and system resources
such as time, effort, CPU, memory, computation power, network bandwidth, files, databases,
etc., as effectively and efficiently as possible. For a software project to succeed, efficiency is
crucial. In addition to meeting the needs for which the software was made, it must also provide
excellent features designed to assist users in completing their tasks faster. Software should
make efficient use of storage space and execute commands according to timing requirements.
In order to be efficient, software must offer users proper value in terms of their time and cash.
The market is filled with products that cater to various industries, but only a handful of
products are efficient enough to benefit individuals and businesses. The medical billing
software that Open Practice Solutions provides, for instance, makes billing processes much
more efficient for clients than those offered by other companies.

o Flexibility: Software Flexibility refers to the ability of the software solution to adapt to
potential or future changes in its requirements. When evaluating the flexibility of software,
look at how simple it is to add, modify, or remove features without interfering with the current
operation. It is essential to keep up with rapidly changing markets, technologies, and customer
needs. In software development, change is inevitable; it can arise during the development
process itself or as the result of future requirements. Flexibility is therefore highly valued.
Consequently, any software product must be scalable, flexible, and easily adaptable to future
technology. When designing or building a software product, be sure to plan for these changes
that are inevitably going to occur. Loose coupling of components is the key to creating highly
flexible systems.

o Reliability: The reliability of a software product describes the likelihood it will operate without
failure over a specified period of time under certain conditions. It determines the ability of
software to maintain its level of performance (provide desired functionality) under specified
conditions for a specified period of time. Generally speaking, software reliability is measured
as the availability of the software. The value should not be less than 99%. In reliability testing,
the goal is not perfection, but achieving a level of reliability that is acceptable before a software
product is released to customers. MTTF, MTTR, MTBR, etc., are some reliability metrics that
can be used to quantify the reliability of a software product. It is regarded as one of the most
important quality aspects of software quality, along with functionality, efficiency,
maintainability, etc. Since software tends to be complex, it is hard to achieve software
reliability.

o Maintainability: Maintainability refers to how easily you can repair, improve and comprehend
software code. In some ways, maintaining is similar to being flexible. Maintainability deals
 with the modification of errors and minor alterations to software code, while flexibility focuses
on major functional extensions. It also involves maintaining the services and functionality of
the software. Most of the time, developers are not the ones who maintain the software.
Therefore, good documentation is crucial, which includes code documentation, interface
definitions, etc. The maintainability of software products is affected by the quality of the
documentation. Typically, more than half of development budgets are spent on software
maintenance. Maintenance should therefore be integrated into the development lifecycle for
effective software maintenance.

o Portability: Software portability is a critical factor that cannot be ignored. Portability refers to
the ability to use software in different environments. This is the ease with which software can
be ported from one platform to another without (or with minimal) changes, while obtaining
similar results. As simple as it may sound, it refers to the ability of software to work on
different hardware platforms without any (or little) modifications needed. Furthermore, you
should be aware that porting software to a new environment is comparatively cheaper than
developing an equivalent application from scratch. There can be no doubt that portability is a
crucial aspect of reducing development costs.

o Integrity: There are multiple interpretations of software integrity. Some people tend to
associate integrity with security, believing it is resistant to hacks and privacy violations. To
others, high integrity means that the software cannot be modified without authorization.
Integrity is key for demonstrating the safety, security, and maintainability of your software. In
addition, software that needs to be compliant with industry regulations and coding standards
requires high code integrity. Achieving software integrity can be difficult. Yet, with the right
practices to improve safety, security, and maintainability, the challenge can be easily
overcome. In these days of increased security threats, all software must include this factor.

2 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, same tools even though rapidly increasing in software demand, the complexity of
software, and software challenges. With the increase in the complexity of software, many software
problems arise because existing methods were insufficient. If we will use the same workforce, same
methods, and same tools after the fast increase in software demand, software complexity, and
software challenges, then there arise some problems like software budget problems, software
efficiency problems, software quality problems, software managing and delivering problem, etc.
This condition is called a software crisis.
Causes of Software Crisis:

 The cost of owning and maintaining software was as expensive as developing the software
 At that time Projects were running over-time
 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.
 Difficult to alter, debug, and enhance.
 The software complexity is harder to change.
 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 software must be high.
 Less time is needed for a software project.
 Experienced and skilled people working over the software project.
 Software must be delivered.
 Software must meet user requirements.
3 Software Processes

Software is the set of instructions in the form of programs to govern the computer system and to
process the hardware components. To produce a software product the set of activities is used. This
set is called a software process.

There are four basic key process activities:

 Software Specifications – In this process, detailed description of a software system to be

developed with its functional and non-functional requirements.
 Software Development – In this process, designing, programming, documenting, testing,
and bug fixing is done.
 Software Validation – In this process, evaluation software product is done to ensure that the
software meets the business requirements as well as the end user’s needs.
 Software Evolution – It is a process of developing software initially, then timely updating it
for various reasons.

3.1 Software Process Model

A software process model is an abstraction of the actual process, which is being described. It can
also be defined as a simplified representation of a software process. Each model represents a process
from a specific perspective. Basic software process models on which different type of software
process models can be implemented:

 A workflow Model – It is the sequential series of tasks and decisions that make up a
business process.
 The Waterfall Model – It is a sequential design process in which progress is seen as flowing
steadily downwards. Phases in waterfall model:
i. Requirements Specification
ii. Software Design
iii. Implementation
iv. Testing
 Dataflow Model – It is diagrammatic representation of the flow and exchange of information
within a system.
 Evolutionary Development Model – Following activities are considered in this method:
i. Specification
ii. Development
iii. Validation
 Role / Action Model – Roles of the people involved in the software process and the activities.

Software Process Framework details the steps and chronological order of a process. Since it serves as a
foundation for them, it is utilized in most applications. Task sets, umbrella activities, and process
framework activities all define the characteristics of the software development process. Software
Process includes:
 1. Tasks: They focus on a small, specific objective.
2. Action: It is a set of tasks that produce a major work product.
3. Activities: Activities are groups of related tasks and actions for a major objective.

Process Framework Activities

The process framework is required for representing common process activities. Five framework
activities are described in a process framework for software engineering. Communication, planning,
modeling, construction, and deployment are all examples of framework activities. Each engineering
action defined by a framework activity comprises a list of needed work outputs, project milestones,
and software quality assurance (SQA) points.
o Communication: By communication, customer requirement gathering is done. Communication
with consumers and stakeholders to determine the system’s objectives and the software’s
requirements.

o Planning: Establish engineering work plan, describes technical risk, lists resources requirements,
work produced and defines work schedule.
o Modeling: Architectural models and design to better understand the problem and to work towards
the best solution. The software model is prepared by:

o Construction: Creating code, testing the system, fixing bugs, and confirming that all criteria are
met. The software design is mapped into a code by:

o Deployment: In this activity, a complete or non-complete product or software is represented to the

customers to evaluate and give feedback. On the basis of their feedback, we modify the product for
the supply of better products.

o Umbrella Activities: Umbrella Activities are that take place during a software development
process for improved project management and tracking.

o Software project tracking and control: This is an activity in which the team can assess
progress and take corrective action to maintain the schedule. Take action to keep the
project on time by comparing the project’s progress against the plan.
o Risk management: The risks that may affect project outcomes or quality can be
analyzed. Analyze potential risks that may have an impact on the software product’s
quality and outcome.
o Software quality assurance: These are activities required to maintain software quality.
Perform actions to ensure the product’s quality.
o Formal technical reviews: It is required to assess engineering work products to uncover
and remove errors before they propagate to the next activity. At each level of the
process, errors are evaluated and fixed.
o Software configuration management: Managing of configuration process when any
change in the software occurs.
o Work product preparation and production: The activities to create models, documents,
logs, forms, and lists are carried out.
o Reusability management: It defines criteria for work product reuse. Reusable work
items should be backed up, and reusable software components should be achieved.
o Measurement: In this activity, the process can be defined and collected. Also, project
and product measures are used to assist the software team in delivering the required
software.

4 Similarity and Differences from Conventional Engineering Processes

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.

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.
Conventional Engineering is basically related to computers, writing programs, and implementing
them.

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.

Difference Between Software Engineering Process and Conventional Engineering Process

Software Engineering Process Conventional Engineering Process

Software Engineering Process is a process that
majorly involves computer science, information
technology, and discrete mathematics.
It is mainly related to computers, programming, and
writing codes for building applications.
In Software Engineering Process construction and
development cost is low.
It can involve the application of new and untested
elements in software projects.
In Software Engineering Process, most development
effort goes into building new designs and features.
It majorly emphasizes quality.
Product development develops intangible products
(software).
Design requirements may change throughout the
development process.
Testing is an integral part of the development
process.
Prototyping is common and helps to refine
requirements.
Maintenance and updates are necessary to keep
software relevant.
Software development often involves complex logic
and algorithms.
Software development often follows established
standards and frameworks.
Software development is typically less expensive to
start, but costs may increase with maintenance and
updates.
Agile methodologies are commonly used in software
development.
The conventional Engineering Process is a process
that majorly involves science, mathematics, and
empirical knowledge.
It is about building cars, machines, hardware,
buildings, etc.
In Conventional Engineering Process construction
and development cost is high.
It usually applies only known and tested principles
to meet product requirements.
In Conventional Engineering Process, most
development efforts are required to change old
designs.
It majorly emphasizes mass production.
Product development develops tangible products
(e.g. bridges, buildings).
Design Requirements are typically well-defined
upfront.
Testing occurs mainly after product completion.
Prototyping is less common due to cost and time.
Maintenance is typically scheduled or reactive.
Conventional engineering may have more complex
physical properties to deal with.
Conventional engineering may have well-
established regulations and standards.
Conventional engineering may be more expensive
to start due to materials and construction but may
have lower maintenance costs.
Conventional engineering may use more
traditional project management approaches.

5 Software quality attributes

Software Quality shows how good and reliable a product is. To convey an associate degree example,
think about functionally correct software. It performs all functions as laid out in the SRS document.
But, it has an associate degree virtually unusable program. even though it should be functionally
correct, we tend not to think about it to be a high-quality product.

Another example is also that of a product that will have everything that the users need but has an
associate degree virtually incomprehensible and not maintainable code. Therefore, the normal
construct of quality as “fitness of purpose” for code merchandise isn’t satisfactory.

Factors of Software Quality: The modern read of high-quality associates with software many quality
factors like the following:

 Portability: A software is claimed to be transportable, if it may be simply created to figure in

several package environments, in several machines, with alternative code merchandise, etc.
 Usability: A software has smart usability if completely different classes of users (i.e.
knowledgeable and novice users) will simply invoke the functions of the merchandise.
 Reusability: A software has smart reusability if completely different modules of the
merchandise will simply be reused to develop new merchandise.
 Correctness: Software is correct if completely different needs as laid out in the SRS document
are properly enforced.
 Maintainability: A software is reparable, if errors may be simply corrected as and once they
show up, new functions may be simply added to the merchandise, and therefore the
functionalities of the merchandise may be simply changed, etc
 Reliability. Software is more reliable if it has fewer failures. Since software engineers do not
deliberately plan for their software to fail, reliability depends on the number and type of
mistakes they make. Designers can improve reliability by ensuring the software is easy to
implement and change, by testing it thoroughly, and also by ensuring that if failures occur, the
system can handle them or can recover easily.
 Efficiency. The more efficient software is, the less it uses of CPU-time, memory, disk space,
network bandwidth, and other resources. This is important to customers in order to reduce their
costs of running the software, although with today’s powerful computers, CPU time, memory
and disk usage are less of a concern than in years gone by.

4 Software life cycle models

A software life cycle model (also termed process model) is a pictorial and diagrammatic representation
of the software life cycle. A life cycle model represents all the methods required to make a software
product transit through its life cycle stages. It also captures the structure in which these methods are to
be undertaken.

In other words, a life cycle model maps the various activities performed on a software product from its
inception to retirement. Different life cycle models may plan the necessary development activities to
phases in different ways. Thus, no element which life cycle model is followed, the essential activities
are contained in all life cycle models though the action may be carried out in distinct orders in
different life cycle models. During any life cycle stage, more than one activity may also be carried out.
SDLC Cycle represents the process of developing software. SDLC framework includes the following
steps:

The stages of SDLC are as follows:

Stage1: Planning and requirement analysis

Requirement Analysis is the most important and necessary stage in SDLC. The senior members of the
team perform it with inputs from all the stakeholders and domain experts or SMEs in the industry.
Planning for the quality assurance requirements and identifications of the risks associated with the
projects is also done at this stage. Business analyst and Project organizer set up a meeting with the
client to gather all the data like what the customer wants to build, who will be the end user, what is the
objective of the product. Before creating a product, a core understanding or knowledge of the product
is very necessary.

For Example, A client wants to have an application which concerns money transactions. In this
method, the requirement has to be precise like what kind of operations will be done, how it will be
done, in which currency it will be done, etc.

Once the required function is done, an analysis is complete with auditing the feasibility of the growth
of a product. In case of any ambiguity, a signal is set up for further discussion. Once the requirement is
understood, the SRS (Software Requirement Specification) document is created. The developers
should thoroughly follow this document and also should be reviewed by the customer for future
reference.

Stage2: Defining Requirements

Once the requirement analysis is done, the next stage is to certainly represent and document the
software requirements and get them accepted from the project stakeholders. This is accomplished
through "SRS"- Software Requirement Specification document which contains all the product
requirements to be constructed and developed during the project life cycle.

Stage3: Designing the Software

The next phase is about to bring down all the knowledge of requirements, analysis, and design of the
software project. This phase is the product of the last two, like inputs from the customer and
requirement gathering.

Stage4: Developing the project

In this phase of SDLC, the actual development begins, and the programming is built. The
implementation of design begins concerning writing code. Developers have to follow the coding
guidelines described by their management and programming tools like compilers, interpreters,
debuggers, etc. are used to develop and implement the code.

Stage5: Testing

After the code is generated, it is tested against the requirements to make sure that the products are
solving the needs addressed and gathered during the requirements stage. During this stage, unit testing,
integration testing, system testing, acceptance testing are done.

Stage6: Deployment

Once the software is certified, and no bugs or errors are stated, then it is deployed. Then based on the
assessment, the software may be released as it is or with suggested enhancement in the object segment.
After the software is deployed, then its maintenance begins.

Stage7: Maintenance

Once when the client starts using the developed systems, then the real issues come up and
requirements to be solved from time to time. This procedure where the care is taken for the developed
product is known as maintenance.

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

Step 1. Requirements analysis and specification phase: The aim of this phase is to understand the
exact requirements of the customer and to document them properly. Both the customer and the
software developer work together so as to document all the functions, performance, and interfacing
requirement of the software. It describes the "what" of the system to be produced and not "how”. In
this phase, a large document called Software Requirement Specification (SRS) document is created
which contained a detailed description of what the system will do in the common language.

Step 2. Design Phase: This phase aims to transform the requirements gathered in the SRS into a
suitable form which permits further coding in a programming language. It defines the overall software
architecture together with high level and detailed design. All this work is documented as a Software
Design Document (SDD).
Step 3. Implementation and unit testing: During this phase, design is implemented. If the SDD is
complete, the implementation or coding phase proceeds smoothly, because all the information needed
by software developers is contained in the SDD.4 Pro is FINALLY Getting This Killer Feature!

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.

Step 4. Integration and System Testing: This phase is highly crucial as the quality of the end
product is determined by the effectiveness of the testing carried out. The better output will lead to
satisfied customers, lower maintenance costs, and accurate results. Unit testing determines the
efficiency of individual modules. However, in this phase, the modules are tested for their interactions
with each other and with the system.

Step 5. Operation and maintenance phase: Maintenance is the task performed by every user once
the software has been delivered to the customer, installed, and operational.

Some Circumstances where the use of the Waterfall model is most suited are:
o When the requirements are constant and not changed regularly.
o A project is short
o The situation is calm
o Where the tools and technology used is consistent and is not changing
o When resources are well prepared and are available to use.

Advantages of Waterfall model

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

Disadvantages of Waterfall model

o In this model, the risk factor is higher, so this model is not suitable for more significant and
complex projects.
o This model cannot accept the changes in requirements during development.
o It becomes tough to go back to the phase. For example, if the application has now shifted to the
coding phase, and there is a change in requirement, it becomes tough to go back and change it.
o Since the testing done at a later stage, it does not allow identifying the challenges and risks in
the earlier phase, so the risk reduction strategy is difficult to prepare.
4.2 Prototype Model

The prototype model requires that before carrying out the development of actual software, a working
prototype of the system should be built. A prototype is a toy implementation of the system. A
prototype usually turns out to be a very crude version of the actual system, possible exhibiting limited
functional capabilities, low reliability, and inefficient performance as compared to actual software. In
many instances, the client only has a general view of what is expected from the software product. In
such a scenario where there is an absence of detailed information regarding the input to the system, the
processing needs, and the output requirement, the prototyping model may be employed.
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 their expectation from the system is.

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: Refine requirement incorporation customer suggestion- 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: Customer evaluation of 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.

Step 6: Acceptance by customer- Once the user is satisfied with the re-developed prototype, only
then the final system is start developing based on the approved final prototype.

…….Remaining steps are same as waterfall

model

Advantage of Prototype Model

 Reduce the risk of incorrect user requirement
 Good where requirement are changing/uncommitted
 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
o Costs customer money
o Needs committed customer
o Difficult to finish if customer withdraw
o 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.

4.3 Evolutionary model

Evolutionary model is a combination of Iterative and Incremental model of 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. The Evolutionary development model divides the
development cycle into smaller, incremental waterfall models in which users are able to 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 start of the project to the delivery time of a solution is
very high. Evolutionary model solves this problem in a different approach.
Evolutionary model suggests breaking down of 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 in 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:
 In evolutionary model, a user gets a chance to experiment partially developed system.
 It reduces the error because the core modules get tested thoroughly.

Disadvantages:
 Sometimes it is hard to divide the problem into several versions that would be acceptable to the
customer which can be incrementally implemented and delivered.

4.4 Spiral models

The spiral model, initially proposed by Boehm, is an evolutionary software process model that couples
the iterative feature of prototyping with the controlled and systematic aspects of the linear sequential
model. It implements the potential for rapid development of new versions of the software. Using the
spiral model, the software is developed in a series of incremental releases. During the early iterations,
the additional release may be a paper model or prototype. During later iterations, more and more
complete versions of the engineered system are produced.

Each cycle in the spiral is divided into four parts:

Objective setting: Each cycle in the spiral starts with the identification of purpose for that cycle, the
various alternatives that are possible for achieving the targets, and the constraints that exists.

Risk Assessment and reduction: The next phase in the cycle is to calculate these various alternatives
based on the goals and constraints. The focus of evaluation in this stage is located on the risk
perception for the project.

Development and validation: The next phase is to develop strategies that resolve uncertainties and
risks. This process may include activities such as benchmarking, simulation, and prototyping.

Planning: Finally, the next step is planned. The project is reviewed, and a choice made whether to
continue with a further period of the spiral. If it is determined to keep, plans are drawn up for the next
step of the project.

The development phase depends on the remaining risks. For example, if performance or user-interface
risks are treated more essential than the program development risks, the next phase may be an
evolutionary development that includes developing a more detailed prototype for solving the risks.

The risk-driven feature of the spiral model allows it to accommodate any mixture of a specification-
oriented, prototype-oriented, simulation-oriented, or another type of approach. An essential element of
the model is that each period of the spiral is completed by a review that includes all the products
developed during that cycle, including plans for the next cycle. The spiral model works for
development as well as enhancement projects.

When to use Spiral Model?

o When deliverance is required to be frequent.
o When the project is large
o When requirements are unclear and complex
o When changes may require at any time
o Large and high budget projects

Advantages
o High amount of risk analysis
o Useful for large and mission-critical projects.

Disadvantages
o Can be a costly model to use.
o Risk analysis needed highly particular expertise
o Doesn't work well for smaller projects.

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

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.

Specific use cases where this model proves beneficial include:

 Mobile app developement: 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: Developement in e-commerece field often involves constant updates.
Implementing an iterative approach enables the introduction of new functionality.

“EDUCATION AND HARD WORK IS THE PASSPORT TO THE FUTURE, BETTER

TOMORROW BELONGS TO THOSE WHO PREPARE THEMSELVES FOR IT.”

GOOD LUCK….