Chapter 2

 Process Models
Slide Set to accompany
Software Engineering: A Practitioner’s Approach, 7/e
by Roger S. Pressman

1
 What / who / why is Process
Models?
 What: Go through a series of predictable steps--- a road map that
helps you create a timely, high-quality results.
 Who: Software engineers and their managers, clients also. People
adapt the process to their needs and follow it.
 Why: Provides stability, control, and organization to an activity that can
if left uncontrolled, become quite chaotic. However, modern software
engineering approaches must be agile and demand ONLY those
activities, controls and work products that are appropriate.
 What Work products: Programs, documents, and data
 What are the steps: The process you adopt depends on the software
that you are building. One process might be good for aircraft avionic
system, while an entirely different process would be used for website
creation.
 How to ensure right: A number of software process assessment
mechanisms that enable us to determine the maturity of the software
process. However, the quality, timeliness and long-term viability of 2the
software are the best indicators of the efficacy of the process you use.
 Definition of Software Process
 A framework for the activities, actions, and tasks
that are required to build high-quality software.

 SP defines the approach that is taken as software is

engineered.

 Is not equal to software engineering, which also

encompasses technologies that populate the
process– technical methods and automated tools.
3
 As we discussed before, a generic process framework for
software engineering defines five framework activities-
communication, planning, modeling, construction, and
deployment.
 In addition, a set of umbrella activities- project tracking
and control, risk management, quality assurance,
configuration management, technical reviews, and others
are applied throughout the process.
 Next question is: how the framework activities and the
actions and tasks that occur within each activity are
organized with respect to sequence and time? See the
process flow for answer.
4
Process Flow
 process flow—describes how the framework
activities and the actions and tasks that occur
within each framework activity are organized
with respect to sequence and time and is
illustrated in Figure 2.2.

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 5
 Process Flow…..
 A linear process flow executes each of the five framework activities in
sequence, beginning with communication and culminating with
deployment (Figure 2.2a).
 An iterative process flow repeats one or more of the activities before
proceeding to the next (Figure 2.2b).
 An evolutionary process flow executes the activities in a “circular”
manner. Each circuit through the five activities leads to a more
complete version of the software (Figure 2.2c).
 A parallel process flow (Figure 2.2d) executes one or more activities in
parallel with other activities

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 6
Process Flow

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 7
Identifying a Task Set
 A task set defines the actual work to be done to
accomplish the objectives of a software
engineering action.
 A list of the task to be accomplished(Choose a task set that best
accommodates the needs of the project and the characteristics of team)
 A list of the work products to be produced
 A list of the quality assurance filters to be applied

8
Process Patterns
 A process pattern
 describes a process-related problem that is
encountered during software engineering work,
 identifies the environment in which the problem has
been encountered, and
 suggests one or more proven solutions to the
problem.
 Stated in more general terms, a process pattern provides
you with a template
 a consistent method for describing problem solutions
within the context of the software process.

9
  proposed a template for describing a process
pattern:
 Pattern Name.
The pattern is given a meaningful name describing it within the
context of the software process.
 Forces.
The environment in which the pattern is encountered and the
issues that make the problem visible and may affect its solution.
 Type.
The pattern type is specified. There are three types:

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 10
 Process Pattern Types
 Stage patterns—defines a problem associated with a
framework activity for the process.
 An example of a stage pattern might be Establishing Communication. This pattern would incorporate the
task pattern Requirements Gathering and others.

 Task patterns—defines a problem associated with a

software engineering action or work task and relevant
to successful software engineering practice(e.g., Requirements
Gathering is a task pattern).

 Phase patterns—define the sequence of framework

activities that occur with the process, even when the
overall flow of activities is iterative in nature. (An example of
a phase pattern might be Spiral Model or Prototyping)

11
 Process Assessment and Improvement

 SP cannot guarantee that software will be delivered

on time, meet the needs, or has the desired technical
characteristics. However, the process can be
assessed to ensure that it meets a set of basic
process criteria that have been shown to be essential
for a successful software engineering.

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 12
Process Assessment and Improvement

 Standard CMMI Assessment Method for Process Improvement

(SCAMPI) — provides a five step process assessment model that
incorporates five phases: initiating, diagnosing, establishing, acting and
learning.
 CMM-Based Appraisal for Internal Process Improvement (CBA
IPI)—provides a diagnostic technique for assessing the relative
maturity of a software organization; uses the SEI CMM as the basis for
the assessment
 SPICE—The SPICE (ISO/IEC15504) standard defines a set of
requirements for software process assessment. The intent of the
standard is to assist organizations in developing an objective
evaluation of the efficacy of any defined software process.

 ISO 9001:2000 for Software—a generic standard that applies to any

organization that wants to improve the overall quality of the products,
systems, or services that it provides. Therefore, the standard is directly
applicable to software organizations and companies.
Software Engineering Institute Capability Maturity Model
.

13
Prescriptive Models
 Prescriptive process models advocate an orderly approach to
software engineering
That leads to a few questions …
 If prescriptive process models strive for structure and order,
are they inappropriate for a software world that thrives on
change?
 Yet, if we reject traditional process models (and the order they
imply) and replace them with something less structured, do we
make it impossible to achieve coordination and coherence in
software work?

14
 1. The Waterfall Model
Communicat ion
project init iat ion Planning
requirement gat hering estimating Modeling
scheduling
analysis Const ruct ion
tracking
design Deployment
code
t est delivery
support
f eedback

15
 The Waterfall Model…..
 when the requirements for a problem are well understood—when work
flows from communication through deployment in a reasonably linear
fashion
 The waterfall model, sometimes called the classic life cycle, suggests a
systematic, sequential approach to software development that begins with
customer specification of requirements and progresses through planning,
modeling, construction, and deployment, culminating in ongoing support
of the completed software .
 The waterfall model is the oldest paradigm for software engineering.
However Among the problems that are sometimes encountered when the
waterfall model is applied are:

16
 The Waterfall Model…..
1.The main drawback of the waterfall is the difficulty of accommodating change after the process
is underway.
2. Real projects rarely follow the sequential flow that the model proposes. Although
the linear model can accommodate iteration, it does so indirectly. As a result,
changes can cause confusion as the project team proceeds.
3. It is often difficult for the customer to state all requirements explicitly. The
waterfall model requires this and has difficulty accommodating the natural
uncertainty that exists at the beginning of many projects.
4. The customer must have patience. A working version of the program(s) will
not be available until late in the project time span. A major blunder, if undetected
until the working program is reviewed, can be disastrous.
The waterfall model is mostly used for large system engineering project where a
system is developed at several sites

. 17
  The classic life cycle leads to “blocking states” in which some
project team members must wait for other members of the team to
complete dependent tasks. In fact, the time spent waiting can
exceed the time spent on productive work.
 Today, software work is fast-paced and subject to a never-ending
stream of changes (to features, functions, and information content).
The waterfall model is often inappropriate for such work.

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 18
The V-Model
 A variation in the representation of the waterfall model is called the V-
model. Represented in Figure 2.4, the V-model [Buc99] depicts the
relationship of quality assurance actions to the actions associated with
communication, modeling, and early construction activities.
 As a software team moves down the left side of the V, basic problem
requirements are refined into progressively more detailed and technical
representations of the problem and its solution.
 Once code has been generated, the team moves up the right side of
the V, essentially performing a series of tests (quality assurance
actions) that validate each of the models created as the team moved
down the left side.
 In reality, there is no fundamental difference between the classic life
cycle and the V-model. The V-model provides a way of visualizing how
verification and validation actions are applied to earlier engineering
work.

. 19
 A variation of waterfall model
depicts the relationship of
The V-Model quality assurance actions to
the actions associated with
communication, modeling and
early code construction
activates.

Team first moves down the left

side of the V to refine the
problem requirements. Once
code is generated, the team
moves up the right side of the
V, performing a series of tests
that validate each of the
models created as the team
moved down the left side.

20
2. The Incremental Model

increment # n
Co m m u n i c a t i o n
Pla nning
M odeling
an a ly s is Co n s t ru c t i o n
de s ig n
c od e De p l o y m e n t
t es t d e l i v e ry
fe e dba c k

deliv ery of
nt h increment
increment # 2

Co m m u n i c a t i o n
Pla nning

M odeling
a n a ly s i s Co n s t ru c t i o n
d e s ig n c o de De p l o y m e n t
t es t d e l i v e ry
fe e dba c k
deliv ery of
increment # 1 2nd increment

Co m m u n i c a t i o n
Pla nning
M odeling
a n al y s is Co n s t ru c t i o n
d e s i gn c od e De p l o y m e n t
t es t d e l i v e ry deliv ery of
fe e dba c k
1st increment

project calendar t ime

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 21
 The Incremental Model
 When initial requirements are reasonably well defined, but the
overall scope of the development effort preclude a purely linear
process. A compelling need to expand a limited set of new
functions to a later system release.
 It combines elements of linear and parallel process flows. Each
linear sequence produces deliverable increments of the
software.
 The first increment is often a core product with many
supplementary features. Users use it and evaluate it with more
modifications to better meet the needs.
 Early increments are stripped-down versions of the final
product, but they do provide capability that serves the user and
also provide platform for evaluation by the user.

 The Incremental Model
 For example, word-processing software developed using the incremental
paradigm might deliver basic file management, editing, and document
production functions in the first increment; more sophisticated editing and
document production
 Capabilities in the second increment; spelling and grammar checking in
the third increment; and advanced page layout capability in the fourth
increment.
.

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 23
3. Evolutionary Models: Prototyping

Q u i ck p l an
Quick
Com m unicat ion plan
communication
Mo d e l i n g
Modeling
Q u i ck d e si g n
Quick design

Deployment
Deployment Construction
De live r y
delivery
& Fe e dback& of Const
prototype
r uct ion
feedback Construction
of
of ot
pr prototype
ot ype

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 24
 Evolutionary Models
 Software system evolves over time as requirements often change as
development proceeds. Thus, a straight line to a complete end product
is not possible. However, a limited version must be delivered to meet
competitive pressure.
 Usually a set of core product or system requirements is well
understood, but the details and extension have yet to be defined.
 You need a process model that has been explicitly designed to
accommodate a product that evolved over time.
 It is iterative that enables you to develop increasingly more complete
version of the software.
 Two types are introduced, namely Prototyping and Spiral models.
25
 Evolutionary Models: Prototyping
 When to use: Customer defines a set of general objectives but does not identify
detailed requirements for functions and features. Or Developer may be unsure
of the efficiency of an algorithm, the form that human computer interaction
should take.
 What step: Begins with communication by meeting with stakeholders to define
the objective, identify whatever requirements are known, outline areas where
further definition is mandatory. A quick plan for prototyping and modeling (quick
design) occur. Quick design focuses on a representation of those aspects the
software that will be visible to end users. ( interface and output). Design leads to
the construction of a prototype which will be deployed and evaluated.
Stakeholder’s comments will be used to refine requirements.
 Both stakeholders and software engineers like the prototyping paradigm. Users
get a feel for the actual system, and developers get to build something
immediately. However, engineers may make compromises in order to get a
prototype working quickly. The less-than-ideal choice may be adopted forever
26

after you get used to it.

Evolutionary Models: The Spiral
planning
estimation
scheduling
risk analysis

communication

modeling
analysis
design
start

deployment
construction
delivery code
feedback test

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 27
 Evolutionary Models: The Spiral
 It couples the iterative nature of prototyping with the controlled and systematic aspects of the
waterfall model and is a risk-driven process model generator that is used to guide multi-
stakeholder concurrent engineering of software intensive systems.
 Two main distinguishing features: one is cyclic approach for incrementally growing a system’s
degree of definition and implementation while decreasing its degree of risk. The other is a set of
anchor point milestones for ensuring stakeholder commitment to feasible and mutually
satisfactory system solutions.
 A series of evolutionary releases are delivered. During the early iterations, the release might be
a model or prototype. During later iterations, increasingly more complete version of the
engineered system are produced.
 The first circuit in the clockwise direction might result in the product specification; subsequent
passes around the spiral might be used to develop a prototype and then progressively more
sophisticated versions of the software. Each pass results in adjustments to the project plan. Cost
and schedule are adjusted based on feedback. Also, the number of iterations will be adjusted by
project manager.
 Good to develop large-scale system as software evolves as the process progresses and risk
should be understood and properly reacted to. Prototyping is used to reduce risk.
 However, it may be difficult to convince customers that it is controllable as it demands
considerable risk assessment expertise. 28
Evolutionary Models: Concurrent
none

Modeling act ivit y

represents the state

Under of a software engineering
activity or task
development

Await ing
changes

Under review

Under
revision

Baselined

Done

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 29
Still Other Process Models
 Component based development—the process to
apply when reuse is a development objective
 Formal methods—emphasizes the mathematical
specification of requirements
 AOSD—provides a process and methodological
approach for defining, specifying, designing, and
constructing aspects
 Unified Process—a “use-case driven, architecture-
centric, iterative and incremental” software process
closely aligned with the Unified Modeling Language
(UML)
These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 30
The Unified Process (UP)
Elaborat ion
elaboration

Incept ion
inception

const ruct ion

Release
t ransit ion
soft ware increment

product ion

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 31
UP Phases
UP Phases
Incept ion Elaborat ion Const ruct ion Transit ion Product ion

Workflows

Requirements

Analysis

Design

Implementation

Test

Support

Iterations #1 #2 #n-1 #n

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 32
 UP Work Products
Incept ion phase

Elaborat ion phase

Vision document
Init ial use-case model
Init ial project glossary
Init ial business case
Init ial risk assessment .
Project plan,
phases and it erat ions.
Business model,
if necessary .
One or more prot ot y pes
I nc e pt i o
n Preliminary design model
Use-case model
Supplement ary requirement s
including non-funct ional
Analy sis model
Soft ware archit ect ure
Descript ion.
Execut able archit ect ural
prot ot y pe.
Rev ised risk list
Project plan including
it erat ion plan
adapt ed workflows
milest ones
t echnical work product s
Preliminary user manual
Const ruct ion phase
Transit ion phase
Design model
Soft ware component s
Int egrat ed soft ware Deliv ered soft ware increment
increment Bet a t est report s
Test plan and procedure General user feedback
Test cases
Support document at ion
user manuals
inst allat ion manuals
descript ion of current
increment

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 33
Personal Software Process (PSP)
 Planning. This activity isolates requirements and develops both size and
resource estimates. In addition, a defect estimate (the number of defects
projected for the work) is made. All metrics are recorded on worksheets or
templates. Finally, development tasks are identified and a project schedule is
created.
 High-level design. External specifications for each component to be constructed
are developed and a component design is created. Prototypes are built when
uncertainty exists. All issues are recorded and tracked.
 High-level design review. Formal verification methods (Chapter 21) are applied
to uncover errors in the design. Metrics are maintained for all important tasks and
work results.
 Development. The component level design is refined and reviewed. Code is
generated, reviewed, compiled, and tested. Metrics are maintained for all
important tasks and work results.
 Postmortem. Using the measures and metrics collected (this is a substantial
amount of data that should be analyzed statistically), the effectiveness of the
process is determined. Measures and metrics should provide guidance for
modifying the process to improve its effectiveness.

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 34
Team Software Process (TSP)
 Build self-directed teams that plan and track their work,
establish goals, and own their processes and plans.
These can be pure software teams or integrated product
teams (IPT) of three to about 20 engineers.
 Show managers how to coach and motivate their teams
and how to help them sustain peak performance.
 Accelerate software process improvement by making
CMM Level 5 behavior normal and expected.
 The Capability Maturity Model (CMM), a measure of the
effectiveness of a software process, is discussed in Chapter 30.
 Provide improvement guidance to high-maturity
organizations.
 Facilitate university teaching of industrial-grade team
skills.

These slides are designed to accompany Software Engineering: A Practitioner’s Approach, 7/e
(McGraw-Hill, 2009). Slides copyright 2009 by Roger Pressman. 35