Software Engineering

UNIT 2: Software Process

Process models, Software process framework – defining a
framework activity, Identifying a task set, Process patterns, Process
assessment and improvement, Software Development Life Cycle,
Prescriptive Process Models– The Waterfall Model– Prototyping,
Spiral Model, Agile Model(9hrs)
 Process models:
A software process model is an abstraction of the software development
process. The models specify the stages and order of a process. It's the order of
activities of the process and the sequence in which they are performed.

A model will define the following:

● The tasks to be performed
● The input and output of each task
● The pre and post-conditions for each task
● The flow and sequence of each task
Goal : To provide guidance for controlling and coordinating the tasks to achieve
the end product and objectives as effectively as possible.
There are many kinds of process models for meeting different
requirements. We call it as SDLC models (Software Development
Life Cycle models). The SDLC models are as follows:
● Waterfall model
● V model
● Incremental model
● RAD model
● Agile model
● Iterative model
● Prototype model
● Spiral model
Factors in choosing a software process
● Project requirements
● Project size
● Project complexity
● Cost of delay
● Customer involvement
● Familiarity with technology
● Project resources
Software Process Framework
A Software Process Framework is a structured approach that
defines the steps, tasks, and activities involved in software
development. This framework serves as a foundation for
software engineering, guiding the development team through
various stages to ensure a systematic and efficient process. A
Software Process Framework helps in project planning, risk
management, and quality assurance by detailing the
chronological order of actions.
A software development framework is a structured set of tools, libraries,
best practices, and guidelines that help developers build software
applications.
It includes
● task sets
● umbrella activities
● process framework activities

Utilizing a well-defined Software Process Framework

enhances productivity, consistency, and the overall quality of
the software product.
● Defining a framework activity
● Identifying a task set
● Process patterns
● Process assessment and improvement
Framework Activities:
● These are broad, fundamental activities that are essential in any software
development process. Common framework activities include:
○ Communication: Engaging with stakeholders to gather and clarify
requirements.
○ Planning: Outlining the work, resources, timelines, and risks for the
project.
○ Modeling: Creating abstract representations of the software, such as
architectural designs or data models.
○ Construction: Writing code, conducting tests, and building the software
product.
○ Deployment: Releasing the software to users, providing training, and
handling feedback or issues.
1.Communication
Definition: Communication involves gathering requirements from
customers and stakeholders to determine the system’s objectives and the
software’s requirements.
Activities:
Requirement Gathering: Engaging with consumers and stakeholders
through meetings, interviews, and surveys to understand their needs and
expectations.
Objective Setting: Clearly defining what the system should achieve based
on the gathered requirements.
2. Planning

Definition: Planning involves establishing an engineering work plan, describing technical

risks, listing resource requirements, and defining a work schedule.

Activities:

Work Plan: Creating a detailed plan that outlines the tasks and activities needed to
develop the software.

Risk Assessment: Identifying potential technical risks and planning how to mitigate them.

Resource Allocation: Determining the resources (time, personnel, tools) required for the
project.

Schedule Definition: Setting a timeline for completing different phases of the project.
3. Modeling
Definition: Modeling involves creating architectural models and designs
to better understand the problem and work towards the best solution.

Activities:
Analysis of Requirements: Breaking down the gathered requirements to
understand what the system needs to do.
Design: Creating architectural and detailed designs that outline how the
software will be structured and how it will function.
4. Construction
Definition: Construction involves creating code, testing the system,
fixing bugs, and confirming that all criteria are met.

Activities:
Code Generation: Writing the actual code based on the design
models.
Testing: Running tests to ensure the software works as intended,
identifying and fixing bugs.
5. Deployment
Definition: Deployment involves presenting the completed or partially
completed product to customers for evaluation and feedback, then making
necessary modifications based on their input.
Activities:
Product Release: Delivering the software to users, either as a full release or in
stages.
Feedback Collection: Gathering feedback from users about their experience with
the software.
Product Improvement: Making changes and improvements based on user
feedback to enhance the product.
Identifying a task set
Task Sets:
● Each framework activity is broken down into specific tasks. A
task set defines the actions that need to be completed within each
activity. For example:
○ In Communication: Conducting interviews, drafting
requirements documents, and reviewing stakeholder
feedback.
○ In Planning: Creating a project schedule, estimating costs,
and identifying potential risks.
Process patterns
Process Patterns:
● These are reusable methods or best practices that help streamline
software development. Process patterns provide solutions to
common problems and guide how to handle specific aspects of the
development process. Examples include:
○ Design pattern: A template for solving common design issues.
○ Testing pattern: A structured approach to ensure the software
meets quality standards.
Process assessment and improvement
Process Assessment:
● This involves evaluating the software process to identify areas of
improvement. Tools like the Capability Maturity Model
Integration (CMMI) can be used to assess the effectiveness of the
process, looking at factors such as project management,
engineering practices, and organizational maturity.
Process Improvement:
● Based on the assessment, steps are taken to refine and enhance
the software process. This might involve adopting new
methodologies, improving collaboration, or introducing
automation tools. The goal is to increase efficiency, reduce
errors, and improve the quality of the software.
Software Process Framework

A broad set of guidelines or best practices for managing how software is developed.

Helps you organize and improve your software development process.

Examples: CMMI

CMMI (Capability Maturity Model Integration): Focuses on improving and

optimizing the software development process through maturity levels. It provides a
structured framework for evaluating and enhancing processes.

Software Process Model

A specific method or approach for developing software, showing the steps to follow.

Guides you through each stage of building software, from start to finish.
Software Development Life Cycle
•A life cycle model is also known as a process model.
•It gives us a pictorial representation of the entire software
development process.
•The life cycle model deals with each phase of the software
development process and includes all the activities that are involved
in its life cycle,
•Stage 1:Planning and requirement analysis
Most important and fundamental stage. Performed by senior members of the team with
input from the customer.
•Stage2:Defining requirements
Once the requirement analysis is done the next step is to clearly define and document
the product requirements and get them approved by the customer. This is done through
an SRS(Software requirement specification)
•Stage 3:Designing
The product architect will come out with best architecture for the product to be
developed based on SRS. Usually more than one design approach for the product
architecture is proposed and documented in a DDS(Design Document Specification)
•Stage 4:Building / developing
In this stage of SDLC the actual development and the product is built. The
programming language is chosen with respect to the type of software being
developed.
•Stage 5:Testing
This stage refers to the testing only stage of the product where product defects
are reported ,tracked, fixed and retested, until the product reaches the quality
standards defined in the SRS.
•Stage 6:Deployment and maintenance
The product may first be released in the limited segment and tested in the real
business environment(UAT-User Acceptance Testing).
THE WATERFALL MODEL

•In waterfall model the sequence of steps that

are followed in this model resemble the flow of a
waterfall.
•As the water falls from top to down, in
waterfall model you are allowed to move in the
direction as that of a waterfall therefore
backtracking is not possible in this type of
model.
 REQUIREMENT AND ANALYSIS

•Understanding the exact requirements of the customers and

documenting them correctly
•Noting all the functions, performance and connecting
requirements with the customer and developer.
•Brainstorming and studying the requirements by going through a
step-by-step analysis
•Creating Software requirement Specification (SRS), a detailed
document describing what the system will do in the common
language
•This phase talks about the “what” of the system and now “how.”
SYSTEM DESIGN

•Transforming the requirements collected in the SRS

into a suitable form which allows further coding in a
programming language.
•Describing the overall software structure with
detailed design.
•Documenting the design, also known as Software
Design Document (SDD).
IMPLEMENTATION

•Implementing the design as per SDD by

developing small programs called ‘units’.
•Testing the functionality of the codes through
Unit testing.
•Integrating the codes in the next phase.
INTEGRATION AND SYSTEM TESTING

•Integrating the unit tested codes into a complete

system
•Functional and Non-functional testing to ensure that
the system meets the requirements.
•Determining the quality of the end product through
comprehensive system testing.
•Reporting the issues if found any anomalies.
SYSTEM DEPLOYMENT

•Deploying the final tested product into the

respective customer environment or in the market.
•Performing a sanity check in the environment
after software deployment to check whether it
functions well or not.
SYSTEM MAINTENANCE

•Ensuring that the software is performing well in the

respective environment.
•Providing maintenance and operational support to
the customers after the deployment and installation
of the software.
•Noting and fixing the issues encountered by the
customers, if any.
•Updating the system with the latest features.
DISADVANTAGES OF WATERFALL
MODEL

• It is difficult to define all the requirements at the beginning.

• This model is not suitable for introducing any changes in the middle.
• Small changes or errors that arise in the completed software may cause a lot
of problem.
• Clients feedback cannot be included in the ongoing project
• Documentation takes a lot of time.
• Testing period comes late in the development process.
• Not desirable for the complex project
ADVANTAGES OF WATERFALL MODEL

●Suited for smaller project

●Verification and Validation is done before each stage
●Documentation is done in each phase
●Project is completed with minimum client
intervention
 WATERFALL MODEL CAN BE USED
WHEN:
●Requirement are not changing frequently
●Project is short
●Requirement is clear
●Environment is stable
SPIRAL MODEL

●The spiral model, initially proposed by Boehm, is

an evolutionary software process model that
couples the iterative feature.
●Using the spiral model, the software is developed
in a series of incremental releases.
●During the early iterations, the additional release
may be a prototype. During later iterations, more
and more complete versions of the engineered
system are produced.
SPIRAL MODEL QUADRANT (PHASES)
1. First Quadrant (Objective Setting)
– Identify the objectives of the phase.
– Examine the risks associated with these objectives.

2. Second Quadrant (Risk Assessment and Reduction)

– A detailed analysis is carried out for each identified project risk.
– Steps are taken to reduce the risks.

3. Third Quadrant (Development and Validation)

– Develop and validate the next level of the product after resolving the identified risks.

4. Fourth Quadrant (Review and Planning)

– Review the results achieved so far with the customer and plan the next iteration.
– Progressively more complete version of the software gets built with each iteration around the
spiral.
WHEN TO USE SPIRAL MODEL

•When deliverance is required to be frequent.

•When the project is large
•When requirements are unclear and complex
•When changes may require at any time
•Large and high budget projects
ADVANTAGES
•High amount of risk analysis
•Useful for large and critical projects.

DISADVANTAGES

•Can be a costly model to use.

•Risk analysis needed highly particular expertise
•Doesn't work well for smaller projects.
AGILE MODEL

The Agile process model is more focused on

delivering working software. Agile can
accommodate changes easily and has shown
tremendous outcomes in delivering software.
That is the reason it has become such a
popular name among IT developers and
organizations
Individuals and Interactions Over Processes and Tools: People
and how they work together are more important than the specific
tools or processes used.
Working Software Over Comprehensive Documentation: The
main goal is to deliver software that works well, rather than
spending too much time on detailed documentation.
Customer Collaboration Over Contract Negotiation: Working
closely with customers and adapting to their needs is more
valuable than sticking strictly to a contract.
Responding to Change Over Following a Plan: Being flexible
and adapting to changes is better than rigidly following a
predefined plan.
AGILE VALUES
● Value 1: Individuals and interactions
In the past, a lot of software teams would concentrate on having the best possible
tools or processes with which to build their software. The Agile
Manifesto suggests that while those things are important, the people behind the
processes are even more so.
● Value 2: Working software
Previously, software developers would spend ages creating detailed
documentation. That was before they even started writing a single line of code.
And while documentation isn’t a bad thing, there comes a point when you should
focus on providing your customers with working software.
● Value 3: Customer collaboration
Once upon a time, contracts were king. You would draw up contracts with your
customers who would then detail the finished product. As a result, there was often
a contrast between what the contract said, what the product did, and what the
customer actually required.
● Value 4: Responding to change
The Agile Manifesto suggests that a software team should have the ability to pivot
and change direction whenever they need to, with a flexible roadmap that reflects
that. A dynamic roadmap can change from quarter to quarter, sometimes even
month to month, and agile teams are able to keep up with those changes.
PROTOTYPING
Prototyping is a generic way of creating a functional replica of any idea,
software, or system requiring more engineering to produce the final result.
The prototype model will provide a miniature replica of your desired end
product, requiring accurate consumer feedback to be crafted accordingly.
The Prototyping Model is one of the most often used SDLC Models. It is
applied when customers do not know the exact project requirements ahead
of time. In this paradigm, a prototype of the eventual product is created,
tested, and refined based on consumer feedback until a final acceptable
prototype is reached, which serves as the foundation for building the final
product.
Prototype Model in Software Engineering
Steps of Prototype Model
The following steps are involved in the working of the Prototype
model:

● Requirement Gathering and Analysis

● Quick Decision-Making
● Building a Prototype
● User Evaluation
● Prototype Refinement
● Building the Final Product and Maintenance
Requirement Gathering and Analysis
It is the first step in building the prototype model. The users are interviewed
to collect and define the requirements for the software product, and various
analysis techniques are applied to this information.

Quick Decision-Making
In this step, a preliminary design of the prototype is made. This is not the
complete design of the product; it just gives the user a brief idea of the
system.

Building a Prototype
In this step, a prototype is made using the information from the previous step.
It is a small working model of the software product being built.
User Evaluation
The prototype built in the previous step is presented to the users. They evaluate
the model for strengths and weaknesses and give their suggestions and
comments to the developers.

Prototype Refinement
The developers use the feedback collected from the users in the previous step to
refine the prototype. This step is repeated again and again until the user is
satisfied with the prototype.

Building the Final Product and Maintenance

The final product is built based on the approved prototype from the previous
step. The product is then deployed in the user environment and undergoes
routine maintenance.
The Prototyping Model is useful when:

1. Requirements are unclear: If you don’t know exactly what the final product
should be, creating a prototype helps figure it out.
2. Requirements keep changing: When project needs are constantly evolving,
prototypes let you adjust and improve quickly.
3. Designing user interfaces: For apps and websites, prototypes help design and
test how users will interact with the product.
4. Complex systems: If the system has complicated parts, prototypes help you test
and refine them before finalizing.
5. Proving feasibility: To show whether a new idea or technology will work,
prototypes demonstrate its potential.
Types of Prototype Models in Software Engineering
1. Throwaway Prototyping
2. Evolutionary Prototyping
3. Incremental Prototyping
4. Extreme Prototyping
Throwaway Prototyping
How It Works:
1. Develop a Prototype: Create a simple version of the system or a specific
feature to demonstrate concepts and gather feedback.
2. Gather Feedback: Use the prototype to interact with users or
stakeholders, gather feedback, and better understand requirements.
3. Refine Requirements: Based on the feedback and insights gained, refine
and finalize the project requirements.
4. Discard the Prototype: Once the prototype has served its purpose, it is
discarded, and development of the final product begins based on the
refined requirements.
Benefits:

● Clarifies Requirements: Helps define and refine requirements by providing a

tangible representation of the system.
● Reduces Risk: Identifies potential issues and misunderstandings early, reducing
the risk of costly changes later.
● Improves Communication: Provides a visual and interactive tool for discussing
ideas with stakeholders and users.

Drawbacks:

● Resource Investment: Requires time and resources to develop the prototype,

which will be discarded.
● Scope Creep: There is a risk of scope creep if feedback leads to continuous
changes and additions.
● Not Reusable: The prototype is not intended to be part of the final product, so it
does not contribute directly to the final system.
Evolutionary Prototyping
Evolutionary Prototyping is an approach to software development where
prototypes are continuously developed and refined through iterative cycles.
Unlike throwaway prototypes, evolutionary prototypes evolve into the final
product through ongoing iterations.
How It Works:
1. Initial Prototype: Start by building a basic version of the system with
core functionalities.
2. Iterative Development: Regularly update and enhance the prototype
based on user feedback and changing requirements.
3. Feedback Integration: Continuously gather user input and refine the
prototype to better meet needs and improve functionality.
4. Evolve to Final Product: Gradually transform the prototype into the final
system through successive iterations and enhancements.
Benefits:

● Adaptive: Can easily incorporate changes and improvements as the project

progresses.
● User Feedback: Ensures that user feedback is integrated throughout development,
resulting in a product that better fits user needs.
● Reduced Risk: Allows early identification of problems and adjustments before
finalizing the product.

Drawbacks:

● Scope Creep: Continuous changes can lead to scope creep if not managed
carefully.
● Resource Intensive: Requires ongoing resources for development, testing, and
feedback integration.
● Potential for Unclear End Goal: Without a clear initial scope, there may be
uncertainty about the final product.
Incremental Prototyping

Incremental is a type of prototyping that enables the division of

the final product into smaller prototypes and then they are
developed individually. This means that different prototypes can
be merged into a single software. This approach is used to reduce
the feedback time between the application development team and
the user.
Incremental Prototyping is a development approach where a project is built and
delivered in small, manageable portions or increments. Each increment adds new
features or improvements to the existing system.
How It Works:

1. Initial Prototype: Start with a basic version of the system that includes core
features.
2. Develop Increments: Gradually develop and add new features or enhancements
in small, incremental stages.
3. User Feedback: After each increment, gather user feedback and make necessary
adjustments or improvements.
4. Integration: Integrate new increments with the existing system to build the final
product progressively.
5. Iterate: Continue developing and refining the system through successive
increments until the final product is achieved.
Benefits:

● Flexibility: Allows for changes and adjustments based on feedback and

evolving requirements.
● Risk Management: Identifies and addresses issues early in the development
process, reducing the risk of major problems later.
● User Involvement: Ensures that user feedback is incorporated throughout the
development, leading to a product that better fits user needs.

Drawbacks:

● Integration Challenges: Integrating multiple increments can be complex and

may lead to compatibility issues.
● Potential Scope Creep: Continuous additions and changes might lead to
scope creep if not carefully managed.
Extreme Prototyping

Extreme Prototyping is a variation of prototyping used primarily in

the context of software development, particularly for web
applications. It is a structured approach that emphasizes rapid
development and iterative refinement to deliver a working product
quickly.
How It Works:

1. Planning: Begin with a detailed understanding of the requirements and objectives. Develop a
project plan that outlines the scope, goals, and schedule.
2. Requirements Analysis: Gather and document requirements from stakeholders. This phase is
usually short and focuses on understanding essential needs and constraints.
3. Design and Development: Rapidly design and develop a prototype based on the requirements.
This involves:
○ Creating a Working Model: Build a functional model of the system that includes core
features.
○ Iterative Refinement: Continuously refine and improve the prototype based on user
feedback and testing.
4. Testing: Regularly test the prototype to identify and fix issues. Testing is often integrated into the
development process to ensure the prototype remains functional and meets user needs.
5. Deployment: Deploy the prototype for user evaluation and feedback. Make necessary adjustments
based on the feedback received.
6. Final Product Development: Once the prototype has been refined and validated, proceed with
developing the final product based on the insights gained from the prototype.
Benefits:

● Speed: Delivers a functional prototype quickly, allowing for fast feedback and
iteration.
● Flexibility: Allows for changes and adjustments based on user feedback and
evolving requirements.
● User-Centric: Engages users early and often, ensuring the final product aligns with
their needs and preferences.
● Risk Reduction: Identifies potential issues and problems early in the development
process, reducing the risk of major failures.

Drawbacks:

● Scope Creep: The rapid and iterative nature of extreme prototyping can lead to
scope creep if not managed carefully.
● Resource Intensive: Requires significant resources for frequent testing, refinement,
and development.