Chapter :Software Process Model

Software process model

 Process models prescribe a distinct set of activities,
actions, tasks, milestones, and work products required
to engineer high quality software.
 Process models are not perfect, but provide roadmap for
software engineering work.
 Software models provide stability, control to a process
that if not managed can easily get out of control
 Software process models are adapted to meet the needs
of software engineers and managers for a specific
project.
SDLC
Software development life cycle
models:
It is a type pf process that represents
the order also in which the activites will
take place.It describes the sequence of
activities graphically to build the final
product.
Build and Fix Model
Build and Fix Model
1. The main objective of this model is to identify the
issue and then fix it as soon as possible.
2. In this model, changes are made at the code level
as early as possible without accepting future issues.
3. This model is an approach to modifying the
software code without little consideration of its
impact on the overall structure of the software
system.
Build and Fix Model
 Techniques used in the initial years of
software developememt resulted into
the term build and fix model.In fact
the model resulted in a number of
project failures because the product
was not constructed using the proper
specification and design. This model
has only historical importance now.
Advantages
1. The main advantage is that it performs its work at low cost
and very quickly.
2. Sometimes, users don’t wait for a long time. Rather, they
require the modified software to be delivered to them in the
least possible time. As a result, the software maintenance
team needs to use a quick-fix model to avoid the time-
consuming process of the Software maintenance life cycle.
3. This model is also advantageous in situations where the
software system is to be maintained with certain deadlines
and limited resources.
Disadvantages
1. This model is not suitable for large project
system and work only for small programming
exercises.
2. The aspect of designing and development in a
structured way is missing.
3. This model is not suitable to fix errors for a
longer period, as the structure of the software
system degrade rapidly.
Prescriptive Model
 Prescriptive process models advocate an orderly approach to software
engineering
 Organize framework activities in a certain order
 Process framework activity with set of software engineering actions.
 Each action in terms of a task set that identifies the work to be
accomplished to meet the goals.
 The resultant process model should be adapted to accommodate the
nature of the specific project, people doing the work, and the work
environment.
 Software engineer choose process framework that includes activities
like;
 Communication
 Planning
 Modeling
 Construction
 Deployment
Prescriptive Model
 Calling this model as “Prescribe”
because it recommend a set of
process elements, activities, action
task, work product & quality.
 Each elements are inter related to
one another (called workflow).
Waterfall Model or Classic Life
Cycle
The Waterfall model is one of the most used model of 70’s.It
was proposed by Royce in 1970 as an alternative to Build and
Fix software development method in which code was written
and debugged.

System was not formally designed and there was no way to

check the quality criteria.

The waterfall software process model is one of the simplest

and most effective software process models. The waterfall
model displays each step of the development process as a
separate, sequential step so that it's easy to follow.
Waterfall Model
 The Waterfall Model was the first Process Model to be
introduced. It is also referred to as a linear-sequential life
cycle model. It is very simple to understand and use. In a
waterfall model, each phase must be completed before
the next phase can begin and there is no overlapping in
the phases.
 The Waterfall model is the earliest SDLC approach that
was used for software development.
 The waterfall Model illustrates the software development
process in a linear sequential flow. This means that any
phase in the development process begins only if the
previous phase is complete. In this waterfall model, the
phases do not overlap.
Waterfall model phases
Explanation:-
• Requirement Gathering and analysis − All possible
requirements of the system to be developed
are captured in this phase and documented in
a requirement specification document.
• System Design − The requirement specifications
from first phase are studied in this phase and
the system design is prepared. This system
design helps in specifying hardware and
system requirements and helps in defining the
overall system architecture.
 Implementation − With inputs from the system
design, the system is first developed in small
programs called units, which are integrated in
the next phase. Each unit is developed and
tested for its functionality, which is referred to
as Unit Testing.
 Integration and Testing − All the units developed
in the implementation phase are integrated
into a system after testing of each unit. Post
integration the entire system is tested for any
faults and failures.
• Deployment of system − Once the functional and
non-functional testing is done; the product is
deployed in the customer environment or
released into the market.
• Maintenance − There are some issues which
come up in the client environment. To fix those
issues, patches are released. Also to enhance
the product some better versions are released.
Maintenance is done to deliver these changes
in the customer environment
 Advantages of the waterfall
model
•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.
17
Drawbacks of Waterfall model
• 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.
Iterative Model:-
 Iterative process starts with a simple
implementation of a subset of the software
requirements and iteratively enhances the
evolving versions until the full system is
implemented. At each iteration, design
modifications are made and new functional
capabilities are added. The basic idea behind
this method is to develop a system through
repeated cycles (iterative) and in smaller
portions at a time (incremental).
The following illustration is a representation of the
Iterative and Incremental model −
 Iterative and Incremental development
is a combination of both iterative design
or iterative method and incremental
build model for development. "During
software development, more than one
iteration of the software development
cycle may be in progress at the same
time." This process may be described as
an "evolutionary acquisition" or
"incremental build" approach."
 In this incremental model, the whole
requirement is divided into various
builds. During each iteration, the
development module goes through the
requirements, design, implementation
and testing phases. Each subsequent
release of the module adds function to
the previous release. The process
continues till the complete system is
ready as per the requirement.
Iterative Model - Applications

• Requirements of the complete system are clearly defined

and understood.
• Major requirements must be defined; however, some
functionalities or requested enhancements may evolve
with time.
• There is a time to the market constraint.
• A new technology is being used and is being learnt by
the development team while working on the project.
• Resources with needed skill sets are not available and
are planned to be used on contract basis for specific
iterations.
• There are some high-risk features and goals which may
change in the future.
Advantages
• Some working functionality can be developed quickly and early in the
life cycle.
• Results are obtained early and periodically.
• Parallel development can be planned.
• Progress can be measured.
• Less costly to change the scope/requirements.
• Testing and debugging during smaller iteration is easy.
• Risks are identified and resolved during iteration; and each iteration
is an easily managed milestone.
• Easier to manage risk - High risk part is done first.
• With every increment, operational product is delivered.
• Issues, challenges and risks identified from each increment can be
utilized/applied to the next increment.

• Risk analysis is better.
• It supports changing requirements.
• Initial Operating time is less.
• Better suited for large and mission-
critical projects.
• During the life cycle, software is
produced early which facilitates
customer evaluation and feedback.
Drawbacks
• Defining increments may require definition
of the complete system.
• Not suitable for smaller projects.
• Management complexity is more.
• End of project may not be known which is a
risk.
• Highly skilled resources are required for risk
analysis.
• Projects progress is highly dependent upon
the risk analysis phase.
• More resources may be required.
• Although cost of change is lesser, but it
is not very suitable for changing
requirements.
• More management attention is required.
• System architecture or design issues
may arise because not all requirements
are gathered in the beginning of the
entire life cycle.
Incremental process model
Incremental process model
 Incremental Model is a process of software
development where requirements divided into
multiple standalone modules of the software
development cycle. In this model, each module
goes through the requirements, design,
implementation and testing phases. Every
subsequent release of the module adds function
to the previous release.
Incremental process model
phases
 1. Requirement analysis: In the first phase of the
incremental model, the product analysis expertise identifies
the requirements. And the system functional requirements
are understood by the requirement analysis team. To
develop the software under the incremental model, this
phase performs a crucial role.
 2. Design & Development: In this phase of the Incremental
model of SDLC, the design of the system functionality and
the development method are finished with success. When
software develops new practicality, the incremental model
uses style and development phase.
 3. Testing: In the incremental model, the testing phase
checks the performance of each existing function as well as
additional functionality. In the testing phase, the various
methods are used to test the behavior of each task
 4. Implementation: Implementation phase enables the
coding phase of the development system. It involves the
final coding that design in the designing and development
phase and tests the functionality in the testing phase. After
completion of this phase, the number of the product
working is enhanced and upgraded up to the final system
product
When we use the Incremental Model?

• When the requirements are superior.

• A project has a lengthy development schedule.
• When Software team are not very well skilled
or trained.
• When the customer demands a quick release of
the product.
• You can develop prioritized requirements first.
Advantages of incremental:-
• Errors are easy to be recognized.
• Easier to test and debug
• More flexible.
• Simple to manage risk because it handled
during its iteration.
• The Client gets important functionality early.
Disadvantages of
incremental:-
• Need for good planning
• Total Cost is high.
• Well defined module interfaces are needed.
Diff between iterative and
incremental model:-
 The iterative model enables incorporating
regular changes. The development team can
easily add new product changes during the
iterative cycle.
 In contrast, the incremental model is more
rigid because the team can only make changes
at the final stage of the development process.
 An iterative approach would be to build the
overall solution/product and then refine some of
the areas that require improvement
 Instead, using an incremental approach
involves building and releasing one feature at a
time depending on priorities defined by the
customer.
Evolutionary Models:-
 The evolutionary model is a combination of
the Iterative and Incremental models of the
software development life cycle.
 The Evolutionary development model divides
the development cycle into smaller, incremental
waterfall models in which users can get access
to the product at the end of each cycle.
Evolutionary Models:-
 The evolutionary model is a combination of
the Iterative and Incremental models of the
software development life cycle.
 The Evolutionary development model divides
the development cycle into smaller, incremental
waterfall models in which users can get access
to the product at the end of each cycle.
Evolutionary Models:-
1. The evolutionary model suggests breaking down work into smaller
chunks, prioritizing them, and then delivering those chunks to the customer
one by one.
2. The number of chunks is huge and is the number of deliveries
made to the customer.
3. 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.
4. The model allows for changing requirements as well as all work is
broken down into maintainable work chunks.
Evolutionary Process Model
 Produce an increasingly more
complete version of the software with
each iteration.
 Evolutionary models are:
 Prototyping
 Spiral Model
 RAD
 Concurrent Development Model
 Fourth Generation Techniques (4GT)
Design of Evolutionary
model:
Applications of Evolutionary
model:
1. It is used in large projects where you can easily
find modules for incremental implementation.
Evolutionary model is commonly used when the
customer wants to start using the core features
instead of waiting for the full software.
2. 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

1. Customer needs are clear and been explained in deep to

the developer team.
2. There might be small changes required in separate parts
but not a major change.
3. As it requires time, so there must be some time left for
the market constraints.
4. Risk is high and continuous targets to achieve and
report to customer repeatedly.
5. It is used when working on a technology is new and
requires time to learn.
Advantages Evolutionary Model

1. Adaptability to Changing Requirements: Evolutionary models work

effectively in projects when the requirements are ambiguous or change often.
They support adjustments and flexibility along the course of development.
2. Early and Gradual Distribution: Functional components or prototypes can be
delivered early thanks to incremental development. Faster user satisfaction and
feedback may result from this.
3. User Commentary and Involvement: Evolutionary models place a strong
emphasis on ongoing user input and participation. This guarantees that the
software offered closely matches the needs and expectations of the user.
4. Improved Handling of Difficult Projects: Big, complex tasks can be
effectively managed with the help of evolutionary models. The development
process is made simpler by segmenting the project into smaller, easier-to-
manage portions.
Disadvantages Evolutionary Model

1. Communication Difficulties: Evolutionary models require

constant cooperation and communication. The strategy may
be less effective if there are gaps in communication or if
team members are spread out geographically.
2. Dependence on an Expert Group: A knowledgeable and
experienced group that can quickly adjust to changes is
needed for evolutionary models. Teams lacking experience
may find it difficult to handle these model’s dynamic
nature.
3. Increasing Management Complexity: Complexity can be
introduced by organizing and managing several increments
or iterations, particularly in large projects. In order to
guarantee integration and synchronization, good project
management is needed.
4. Greater Initial Expenditure: As evolutionary models
necessitate continual testing, user feedback and
prototyping, they may come with a greater starting cost.
This may be a problem for projects that have limited
funding.
Prototype Model:
 Prototyping is defined as the process of
developing a working replication of a
product or system that has to be engineered.
It offers a small-scale facsimile of the end
product and is used for obtaining customer
feedback
 The Prototyping Model is one of the most
popularly used Software Development Life Cycle
Models (SDLC models). This model is used when
the customers do not know the exact project
requirements beforehand. In this model, a
prototype of the end product is first developed,
tested, and refined as per customer feedback
repeatedly till a final acceptable prototype is
achieved which forms the basis for developing the
final product.
 In this process model, the system is partially implemented
before or during the analysis phase thereby giving the
customers an opportunity to see the product early in the life
cycle. The process starts by interviewing the customers and
developing the incomplete high-level paper model. This
document is used to build the initial prototype supporting
only the basic functionality as desired by the customer.
Once the customer figures out the problems, the prototype
is further refined to eliminate them. The process continues
until the user approves the prototype and finds the working
model to be satisfactory.
Steps Prototyping Model

 Step 1: Requirement Gathering and Analysis: This

is the initial step in designing a prototype model. In
this phase, users are asked about what they expect or
what they want from the system.
 Step 2: Quick Design: This is the second step in
Prototyping Model. This model covers the basic
design of the requirement through which a quick
overview can be easily described.
 Step 3: Build a Prototype: This step helps in
building an actual prototype from the
knowledge gained from prototype design.
 Step 4: Initial User Evaluation: This step
describes the preliminary testing where the
investigation of the performance model occurs,
as the customer will tell the strength and
weaknesses of the design, which was sent to the
developer.
 Step 5: Refining Prototype: If any feedback is
given by the user, then improving the client’s
response to feedback and suggestions, the final
system is approved.
 Step 6: Implement Product and Maintain: This
is the final step in the phase of the Prototyping
Model where the final system is tested and
distributed to production, here the program is run
regularly to prevent failures.
 Types of Prototyping Models

1. Rapid Throwaway Prototyping

This technique offers a useful method of exploring
ideas and getting customer feedback for each of them.
In this method, a developed prototype need not
necessarily be a part of the ultimately accepted
prototype. Customer feedback helps in preventing
unnecessary design faults and hence, the final
prototype developed is of better quality .
2. Evolutionary Prototyping:-In this method, the
prototype developed initially is incrementally refined
on the basis of customer feedback till it finally gets
accepted. In comparison to Rapid Throwaway
Prototyping, it offers a better approach that saves time
as well as effort. This is because developing a
prototype from scratch for every iteration of the
process can sometimes be very frustrating for the
developers.
Advantages of Prototyping Model

• The customers get to see the partial product early in the life cycle. This
ensures a greater level of customer satisfaction and comfort.
• New requirements can be easily accommodated as there is scope for
refinement.
• Missing functionalities can be easily figured out.
• Errors can be detected much earlier thereby saving a lot of effort and
cost, besides enhancing the quality of the software.
• The developed prototype can be reused by the developer for more
complicated projects in the future.
• Flexibility in design.
• Early feedback from customers and stakeholders can help guide the
development process and ensure that the final product meets their needs
and expectations.
• Prototyping can be used to test and validate design decisions, allowing
for adjustments to be made before significant resources are invested in
development.
• Prototyping can help reduce the risk of project failure by identifying
potential issues and addressing them early in the process.
• Prototyping can facilitate communication and collaboration among
team members and stakeholders, improving overall project efficiency
and effectiveness.
Disadvantages of the Prototyping Model

• Costly with respect to time as well as money.

• There may be too much variation in requirements each time
the prototype is evaluated by the customer.
• Poor Documentation due to continuously changing
customer requirements.
• It is very difficult for developers to accommodate all the
changes demanded by the customer.
• There is uncertainty in determining the number of iterations
that would be required before the prototype is finally
accepted by the customer.
• After seeing an early prototype, the customers sometimes
demand the actual product to be delivered soon.
• Developers in a hurry to build prototypes may end up with
sub-optimal solutions.
• The customer might lose interest in the product if he/she is
not satisfied with the initial prototype.
• The prototype may not be scalable to meet the future needs
of the customer.
• The prototype may not accurately represent the final product due to
limited functionality or incomplete features.
• The focus on prototype development may shift the focus away from the
final product, leading to delays in the development process.
• The prototype may give a false sense of completion, leading to the
premature release of the product.
• The prototype may not consider technical feasibility and scalability
issues that can arise during the final product development.
• The prototype may be developed using different tools and technologies,
leading to additional training and maintenance costs.
• The prototype may not reflect the actual business requirements of the
customer, leading to dissatisfaction with the final product.
Applications of Prototyping Model

• The Prototyping Model should be used when the

requirements of the product are not clearly understood or
are unstable.
• The prototyping model can also be used if requirements are
changing quickly.
• This model can be successfully used for developing user
interfaces, high-technology software-intensive systems, and
systems with complex algorithms and interfaces.
• The prototyping Model is also a very good choice to
demonstrate the technical feasibility of the product
RAD Model:-
 The Rapid Application Development Model
was first proposed by IBM in the 1980s. The
RAD model is a type of incremental process
model in which there is an extremely short
development cycle. When the requirements are
fully understood and the component-based
construction approach is adopted then the RAD
model is used.
 Various phases in RAD are Requirements
Gathering, Analysis and Planning, Design, Build or
Construction, and finally Deployment.
 The critical feature of this model is the use of
powerful development tools and techniques. A
software project can be implemented using this
model if the project can be broken down into small
modules wherein each module can be assigned
independently to separate teams.
 These modules can finally be combined to form the
final product. Development of each module
involves the various basic steps as in the waterfall
model i.e. analyzing, designing, coding, and then
testing, etc. as shown in the figure. Another
striking feature of this model is a short period i.e.
the time frame for delivery(time-box) is generally
60-90 days.
Phases:-
1. Requirements Planning – It involves the use of various
techniques used in requirements elicitation like
brainstorming, task analysis, form analysis, user scenarios,
FAST (Facilitated Application Development Technique), etc.
It also consists of the entire structured plan describing the
critical data, methods to obtain it, and then processing it to
form a final refined model.
2. User Description – This phase consists of taking user
feedback and building the prototype using developer tools. In
other words, it includes re-examination and validation of the
data collected in the first phase. The dataset attributes are also
identified and elucidated in this phase.
3. Construction – In this phase, refinement of the prototype
and delivery takes place. It includes the actual use of
powerful automated tools to transform processes and data
models into the final working product. All the required
modifications and enhancements are too done in this phase.
4. Cutover – All the interfaces between the independent
modules developed by separate teams have to be tested
properly. The use of powerfully automated tools and
subparts makes testing easier. This is followed by
acceptance testing by the user.
When to use RAD Model?

 When the customer has well-known requirements, the user

is involved throughout the life cycle, the project can be
time-boxed, the functionality delivered in increments, high
performance is not required, low technical risks are
involved and the system can be modularized. In these cases,
we can use the RAD Model. when it is necessary to design
a system that can be divided into smaller units within two
to three months. when there is enough money in the budget
to pay for both the expense of automated tools for code
creation and designers for modeling.
Advantages:

• The use of reusable components helps to reduce the

cycle time of the project.
• Feedback from the customer is available at the
initial stages.
• Reduced costs as fewer developers are required.
• The use of powerful development tools results in
better quality products in comparatively shorter
time spans.
• The progress and development of the project
can be measured through the various stages.
• It is easier to accommodate changing
requirements due to the short iteration time
spans.
• Productivity may be quickly boosted with a
lower number of employees.
Disadvantages:

• The use of powerful and efficient tools requires

highly skilled professionals.
• The absence of reusable components can lead to
the failure of the project.
• The team leader must work closely with the
developers and customers to close the project on
time.
• The systems which cannot be modularized
suitably cannot use this model.
• Customer involvement is required throughout
the life cycle.
• It is not meant for small-scale projects as in
such cases, the cost of using automated tools
and techniques may exceed the entire budget of
the project.
• It requires multiple teams or a large number of
people to work on the scalable projects.
Applications:

1. This model should be used for a system with

known requirements and requiring a short
development time.
2. It is also suitable for projects where requirements
can be modularized and reusable components are
also available for development.
3. The model can also be used when already existing
system components can be used in developing a
new system with minimum changes
4. This model can only be used if the teams
consist of domain experts. This is because
relevant knowledge and the ability to use
powerful techniques are a necessity.
5. The model should be chosen when the budget
permits the use of automated tools and
techniques required.
Spiral Model:-
 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.
 The Spiral Model is a Software Development
Life Cycle (SDLC) model that provides a
systematic and iterative approach to software
development. In its diagrammatic
representation, looks like a spiral with many
loops. The exact number of loops of the spiral
is unknown and can vary from project to
project. Each loop of the spiral is called
a Phase of the software development process.
1. The exact number of phases needed to develop the product
can be varied by the project manager depending upon the
project risks.
2. As the project manager dynamically determines the number
of phases, the project manager has an important role in
developing a product using the spiral model.
3. It is based on the idea of a spiral, with each iteration of the
spiral representing a complete software development cycle,
from requirements gathering and analysis to design,
implementation, testing, and maintenance.
Phases of Spiral Model:-
 Each phase of the Spiral Model is divided into four
quadrants as shown in the above figure. The functions of
these four quadrants are discussed below:
1. Objectives determination and identify alternative
solutions: Requirements are gathered from the customers
and the objectives are identified, elaborated, and analyzed
at the start of every phase. Then alternative solutions
possible for the phase are proposed in this quadrant.
 Identify and resolve Risks: During the
second quadrant, all the possible solutions
are evaluated to select the best possible
solution. Then the risks associated with that
solution are identified and the risks are
resolved using the best possible strategy. At
the end of this quadrant, the Prototype is
built for the best possible solution.
3. Develop the next version of the
Product: During the third quadrant, the
identified features are developed and verified
through testing. At the end of the third quadrant,
the next version of the software is available.
4. Review and plan for the next Phase: In the
fourth quadrant, the Customers evaluate the so-
far developed version of the software. In the
end, planning for the next phase is started.
Risk Handling in Spiral Model

 A risk is any adverse situation that might affect

the successful completion of a software project.
The most important feature of the spiral model
is handling these unknown risks after the
project has started. Such risk resolutions are
easier done by developing a prototype.
1. The spiral model supports coping with risks by
providing the scope to build a prototype at every
phase of software development.
2. The Prototyping Model also supports risk handling,
but the risks must be identified completely before the
start of the development work of the project.
3. But in real life, project risk may occur after the
development work starts, in that case, we cannot use
the Prototyping Model.
4. In each phase of the Spiral Model, the features
of the product dated and analyzed, and the risks
at that point in time are identified and are
resolved through prototyping.
5. Thus, this model is much more flexible
compared to other SDLC models.
Why Spiral Model is called Meta Model?

 The Spiral model is called a Meta-Model because it subsumes all the

other SDLC models. For example, a single loop spiral actually
represents the Iterative Waterfall Model.
1. The spiral model incorporates the stepwise approach of the Classical
Waterfall Model.
2. The spiral model uses the approach of the Prototyping Model by
building a prototype at the start of each phase as a risk-handling
technique.
3. Also, the spiral model can be considered as supporting the Evolutionary
model – the iterations along the spiral can be considered as
evolutionary levels through which the complete system is built.
Advantages of the Spiral Model

1. Risk Handling: The projects with many

unknown risks that occur as the development
proceeds, in that case, Spiral Model is the best
development model to follow due to the risk
analysis and risk handling at every phase.
2. Good for large projects: It is recommended to
use the Spiral Model in large and complex
projects.
3. Flexibility in Requirements: Change requests
in the Requirements at a later phase can be
incorporated accurately by using this model.
4. Customer Satisfaction: Customers can see the
development of the product at the early phase
of the software development and thus, they
habituated with the system by using it before
completion of the total product.
5. Iterative and Incremental Approach: The Spiral
Model provides an iterative and incremental
approach to software development, allowing for
flexibility and adaptability in response to changing
requirements or unexpected events.
6. Emphasis on Risk Management: The Spiral
Model places a strong emphasis on risk
management, which helps to minimize the impact
of uncertainty and risk on the software
development process.
7. Improved Communication: The Spiral Model
provides for regular evaluations and reviews,
which can improve communication between the
customer and the development team.
8. Improved Quality: The Spiral Model allows
for multiple iterations of the software
development process, which can result in
improved software quality and reliability.
Disadvantages of the Spiral Model

1. Complex: The Spiral Model is much more

complex than other SDLC models.
2. Expensive: Spiral Model is not suitable for small
projects as it is expensive.
3. Too much dependability on Risk Analysis: The
successful completion of the project is very much
dependent on Risk Analysis. Without very highly
experienced experts, it is going to be a failure to
develop a project using this model.
4. Difficulty in time management: As the number of phases
is unknown at the start of the project, time estimation is
very difficult.
5. Complexity: The Spiral Model can be complex, as it
involves multiple iterations of the software development
process.
6. Time-Consuming: The Spiral Model can be time-
consuming, as it requires multiple evaluations and reviews.
7. Resource Intensive: The Spiral Model can be resource-
intensive, as it requires a significant investment in
planning, risk analysis, and evaluations.
When To Use the Spiral Model?

1. When a project is vast in software engineering, a spiral model

is utilized.
2. A spiral approach is utilized when frequent releases are
necessary.
3. When it is appropriate to create a prototype
4. When evaluating risks and costs is crucial
5. The spiral approach is beneficial for projects with moderate to
high risk.
6. The SDLC’s spiral model is helpful when requirements are
complicated and ambiguous.
7. If modifications are possible at any moment
Fourth Generation Techniques(4GT)
4GT
 Like all other models, 4GT begins with a requirements
gathering phase.
 Ideally, the customer would describe the requirements, which
are directly translated into an operational prototype.
 Practically, however, the client may be unsure of the
requirements, may be ambiguous in his specs or may be
unable to specify information in a manner that a 4GT tool can
use.
 For small applications, it may be possible to move directly from
the requirements gathering phase to the implementation phase
using a nonprocedural fourth generation language.
 However for larger projects a design strategy is necessary.
Otherwise, the same difficulties are likely to arise as with
conventional approaches.
4GT
 To transform a 4GT implementation into a product, the
developer must conduct thorough testing, develop meaningful
documentation.
 In addition, the 4GT developed software must be built in a
manner that enables maintenance to be performed quickly.
Merits:
 Dramatic reduction in software development time. (For small
and intermediate application)
 Improved productivity for software developers.
Demerits:
 Not much easier to use as compared to programming
languages
 The maintainability of large software systems built using 4GT is
open to question.
4GT
 4GT Software tool is used to generate the source code
for a software system from a high level specification
representation
 Commonly used 4GT in development models are
mentioned below:
 Report Generation
 Data base query language
 Data Manipulation
 Screen definition and interaction
 Code Generation
 Web engineering Tools
 high-level graphics
Component Based Development
 component-based development (CBD) model
incorporates many of the characteristics of the
spiral model.
 It is evolutionary by nature and iterative
approach to create software.
 CBD model creates applications from
prepackaged software components (called
classes).
CBD Model
CBD model (cont.)
 Modeling and construction activities begin with identification of
candidate components.
 Classes created in past software engineering projects are
stored in a class library or repository.
 Once candidate classes are identified, the class library is
searched to determine if these classes already exist.
 If class is already available in library extract and reuse it.
 If class is not available in library, it is engineered or developed
using object-oriented methods.
 Any new classes built to meet the unique needs of the
application.
 Now process flow return to the spiral activity.
CBD model (cont.)
 CBD model leads to software
reusability.
 Based on studies, CBD model leads to
70 % reduction in development cycle
time.
 84% reduction in project cost.
 Productivity is very high.