CS 5150

Software Engineering

Lecture 3

Software Processes 2

CS 5150 1
 Administration

Project teams
• Any announcement to class?
• People who would like to form teams?
Project Suggestions on the web site
Entrepreneurship experiment

CS 5150 2
 Administration

Project teams
When you have formed your team and reached
agreement with your client, please send a message
to:
wya@cs.cornell.edu and stevepurpura@gmail.com
with the names of the team, the client's name, and the
topic of the project.

CS 5150 3
 Basic Process Steps in all Software Development

• Feasibility and planning

• Requirements
In a lightweight
• System and program design
process, these steps
• Implementation are repeated with
each increment
• Acceptance and release

• Operation and maintenance

CS 5150 4
 Process Step: Feasibility

A feasibility study precedes the decision to begin a project.

• What is the scope of the proposed project?
• Is the project technically feasible?
• What are the projected benefits?
• What are the costs, timetable?
A feasibility study leads to a decision: go or no-go.

CS 5150 5
 Process Step: Requirements

Requirements define the function of the system from the

client's viewpoint.
The requirements establish the system's functionality,
constraints and goals by consultation with the client,
customers, and users.
The requirements may be developed in a self-contained
study, or may emerge incrementally.

CS 5150 6
 Process Step: System and Program Design

Design describes the system from the software

developers' viewpoint
System design: Establish a system architecture that
matches the requirements to hardware or software
systems.
Program design: Represent the software functions in a
form that can be transformed into one or more executable
programs

CS 5150 7
 Process Step: Implementation

Implementation (coding)
The software design is realized as a set of programs or
program units.
The software components may be written specifically,
acquired from elsewhere, or modified.

CS 5150 8
 Process Step: Acceptance and Release

Acceptance
The system is tested against the requirements by the
client, often with selected customers and users.
Delivery and release
The system is delivered to the client and released into
production or marketed to customers.

CS 5150 9
 Testing

User testing
A preliminary version of the user interface is tested by users.
Their experience may lead to changes in the requirements or the
design.
Program testing
The development team tests components individually (unit
testing) or in combination (system testing) to find bugs, etc.
Acceptance testing
The client tests the final version of the system or parts of the
system against the requirements.

CS 5150 10
 Process Step: Operation and Maintenance

Operation: The system is put into practical use.

Maintenance: Errors and problems are identified and
fixed.
Evolution: The system evolves over time as requirements
change, to add new functions or adapt the technical
environment.
Phase out: The system is withdrawn from service.
This is sometimes called the Software Life Cycle

CS 5150 11
 Sequence of Processes

Every software project will include these basic processes, in some

shape or form, but:
• They may be formal or informal
• They may be carried out in various sequences
Deliverables
In a heavyweight process, each process step creates a deliverable,
usually documentation, e.g., a requirements specification.
In a lightweight process, the deliverables are incremental working
code, with minimal supporting documentation.

CS 5150 12
 Sequence of Processes

Major alternatives
• Sequential: As far as possible, complete each process step
before beginning the next. Waterfall model.
• Iterative: Go quickly through all process steps to create a
rough system, then repeat them to improve the system.
Iterative refinement.
• Incremental: An extension of iterative refinement in which
small increments of software are placed in production. Agile
development.

CS 5150 13
 Sequential Development:
The Waterfall Model

Feasibility study Requirements

Requirements
Design
System design
Implementation
Program design
Implementation (coding)

Testing
Acceptance & release

Operation & maintenance

CS 5150 14
 Iterative Refinement

Evaluation Requirements

Implementation Design

CS 5150 15
 Incremental Development

• Each iteration involves a team working through a full software

development cycle including planning, requirements analysis,
design, coding, unit testing, and acceptance testing.
• Each increment is completed in a fixed time period, e.g., four weeks.
• The size of an increment is based on team size, e.g., 5-10 people.

Increment 1 Increment 2 Increment 3

Accept Accept Accept

Increment 1 Increment 2 Increment 3

CS 5150 16
 Discussion of the Waterfall Model

Advantages:
• Process visibility
• Separation of tasks
• Quality control at each step
• Cost monitoring at each step
Disadvantages:
Each stage in the process reveals new
understanding of the previous stages, which
often requires the earlier stages to be revised.
The Waterfall Model is not enough!

CS 5150 17
 Sequence of Processes

A pure sequential model is impossible

Examples:
• A feasibility study cannot create a proposed budget and
schedule without a preliminary study of the requirements and a
tentative design.
• Detailed design or implementation usually reveals gaps in the
requirements specification.
The plan must allow for some form of iteration.

CS 5150 18
 Modified Waterfall Model

Feasibility study Waterfall model

with feedback
Requirements
This is better
System design

Program design

Implementation (coding)

Testing

Acceptance & release

Operation & maintenance

CS 5150 19
 Discussion of Iterative Refinement

Concept: Initial implementation for client and user

evaluation, but not for release, followed by refinement until
system is complete.
• User interface mock-up
• Throw-away software components
• Dummy modules
• Rapid prototyping
• Successive refinement

CS 5150 20
 Iterative Processes: Requirements and Risk

Mistakes in the requirements are the most expensive to

correct.
Requirements are hard to understand until there is an operational
system, particularly with user interfaces
Create an outline system quickly, review it with clients, test it
with users, improve the understanding of the requirements
Example: Start-up time of launching a complex application.

CS 5150 21
 Incremental Development: Discussion

A simple system with basic functionality is brought quickly

into production. Subsequent increments are based on
experience gained from users of each previous release.
Advantages
• Pay-back on investment begins soon.
• Requirement are more clearly understood in developing
subsequent increments – minimize waste.
• User feedback can be incorporated in later phases.
Challenge
A high-level team must establish overall architecture and
coordinate increments
CS 5150 22
 Incremental Development of Online Systems

When software is released online it is possible to divide it

into small increments that are developed and released in
quick succession.
This approach is excellent for continual enhancement of a
system within an established architecture.
It is not possible for shrink wrapped software, embedded
systems, or similar environments.

CS 5150 23
 Mixed Processes

In practice, many large projects create a process that is

suitable for the specific development. For example:
• A system may use a sequential process with
iteration within the individual process steps. This is
sometimes called a spiral development process.
• User interfaces have to be tested with users. This
forces iterative development, even within an underlying
sequential process.
• A phase 1 system may be developed by iteration
and used as requirements for a phase 2, which is developed
sequentially.

CS 5150 24
 Examples of Mixed Processes:
Iterative Refinement + Waterfall Model:

Problem: Add graphics package to a programming

environment
Phase 1: Iterative refinement
Extend current environment with a preprocessor and run-time
support package. Test with users. Make several new versions until
users are pleased with function. Throw the code away.
Phase 2: Modified waterfall
Use the results of Phase 1 as the basis for a formal set of
requirements. Write new compiler and run-time system
incorporating graphics elements. Make minor adjustments to
requirements as needed.

CS 5150 25
 Corporate Processes

Large software development organizations have their own internal

processes that are designed for their needs. For example:
• Amazon.com (Internet commerce) divides most software
development into phases of about four weeks elapsed time.
• Lockheed Martin (government contactor) follows a process
that fits with the way that the US government manages software
contracts.
• SAP (business software) emphasizes the functionality that
is seen by their business customers.
• Microsoft (PC software) places great emphasis on testing
with a very wide variety of equipment and backward compatibility.

CS 5150 26
 Modern Developments in Software Processes

Changes during the software development process are expensive.

• If the requirements are poorly understood, or expected to
change, select a process that keeps flexibility. Iterative
refinement, phased implementation.
• For big software systems with many inter-related components,
avoid major changes to the design of a system during
development. Sequential process, such as the modified
waterfall model.
• If the market for the software is poorly understood, use an
incremental process that gets operational software in front of
customers as quickly as possible.

CS 5150 27
 Observations about Software Processes

Completed projects should have the basic process steps

but ... the development process is always partly evolutionary.
Risk is lowered by:
• Prototyping key components
• Frequent releases, dividing large projects into phases
• Early and repeated testing with users and customers.
• Following a visible software process
• Making use of reusable components

CS 5150 28
 CS 5150 Project Presentations: Iterative Option

Evaluation Requirements

first presentation

second presentation

third presentation

Implementation
Design

CS 5150 29
 CS 5150 Project Presentations: Sequential Option

Feasibility study 1. Requirements

Requirements 2. Design
System design

Program design
3. Implementation
Implementation (coding)

If you follow a Testing

sequential process the
Acceptance & release
three presentations
should be as shown. Operation & maintenance

CS 5150 30
 CS 5150 Project Presentations: Incremental
Development

Increment 1 Increment 2 Increment 3

First Second Third

release release release

first presentation second presentation third presentation

CS 5150 31