Nexus Learn

Lecture 2: Software Process Models (Prescriptive)

Lecture Notes SE-401 Software Engineering 16 min read Updated 8 Nov 2026

↓ Download notes (Word)

On this page
  1. §1 Process and process model
  2. §2 Plan-driven or agile? A range, not two teams
  3. §3 The Waterfall model and the V-model
  4. §4 Incremental development
  5. §5 Integration and configuration (reuse)
  6. §6 The Spiral model and dealing with change
  7. §7 Choosing a model
  8. Summary
  9. Word bank
  10. Self-check questions

How to use these notes: section numbers (§1.1, §1.2 ...) match the question bank. "Slide L02-S07" means slide 7 of this lecture. Difficult words are explained in "Word help" boxes and in the word bank at the end.

Learning outcomes

By the end of this lecture you should be able to:

SLO

Learning outcome

CLO

Bloom

Slides

SLO 2.1

Explain what a software process and a process model are.

CLO1

C2 Understand

L02-S05

SLO 2.2

Compare plan-driven and agile ways of working.

CLO1

C2 Understand

L02-S06

SLO 2.3

Describe four models: Waterfall, Incremental, Integration and configuration, and Spiral (plus the V-model).

CLO1

C2 Understand

L02-S07, S09-S13

SLO 2.4

Say what each model is good at, and where it fails.

CLO1

C2 Understand

L02-S08, S11-S13, S16

SLO 2.5

Explain why change is the main problem every model must handle.

CLO1

C2 Understand

L02-S14

SLO 2.6

Choose a process model for a real project and give reasons.

CLO1

C3 Apply

L02-S15, S16

In Lecture 1 we learned that every software process has four activities: specification, development, validation and evolution. Today's question is: in what order do we do them, and how many times? The answer is a process model.

§1 Process and process model

Slides L02-S02, L02-S05

§1.1 Recap: the four activities

Slide L02-S02

Activity

In one line

1. Specification

Decide what the software must do

2. Development

Design and build it

3. Validation

Check it is what users need

4. Evolution

Change it over time

Every team does these four activities. A process model is a plan that tells the team in what order to do them and how many times to repeat them.

§1.2 Software process vs process model

Slide L02-S05

Term

Meaning

Software process

The steps a team actually follows to build one software system.

Process model

A general plan for how to build software. Teams change it to fit their project. It is a guide, not strict rules.

Real-world example: biryani

A biryani recipe is like a process model: the general steps everyone knows.

What your mother actually does in her kitchen today is the process. Every home changes the recipe a little, but it is still biryani.

There is always some process, even when a student does an assignment the night before it is due. The real question is whether the process is planned and suitable.

A full process description also says what each step produces (for example a requirements document), who is responsible (analyst, developer, tester), and what must be true before and after each step (for example "the client has approved the requirements").

Word help

model = a simple picture or plan of something real

framework = a basic structure you build on

§2 Plan-driven or agile? A range, not two teams

Slides L02-S06

§2.1 Two ends of a line

Slide L02-S06

Plan-driven

Agile

Idea

Plan everything first, then follow the plan.

Plan a little, build a little, learn, and change the plan often.

Progress is measured by

How much of the plan is done

Working software delivered

Example

Building a motorway: the route, bridges and budget are fixed before work starts.

A food delivery app: the team adds and changes features every few weeks based on what customers do.

Models on the line, from plan-driven to agile: Waterfall, V-model, Spiral, Incremental, Scrum/XP. The positions are rough: Spiral can be run in a more planned or more flexible way, and incremental development can also be planned in advance.

This is not "good vs bad". Most real projects sit somewhere in the middle, and many mix both. Would you choose the plan-driven end for heart pacemaker software? Probably yes. For a food delivery app? Probably the agile end.

Word help

agile = quick and able to change direction easily

plan-driven = following a detailed plan made at the start

§3 The Waterfall model and the V-model

Slides L02-S07 to L02-S09

§3.1 Waterfall: one step after another

Slide L02-S07

1. Requirements: what must the system do?

2. Design: how will it be built?

3. Coding and unit testing: write and test each part.

4. Integration and system testing: join the parts and test the whole.

5. Operation and maintenance: use it, fix it, improve it.

Each step "falls" into the next, like water down steps. Each step produces approved documents, and the next step should not start until the previous one is signed off. In practice the steps overlap a little, but going back is expensive: a requirement change found during testing can mean redoing design, code and tests.

Real-world example: building a house

First the map, then the foundation, then the walls, then the roof.

If you want a basement after the roof is built, it is very costly. Waterfall software works the same way.

History: what Royce really said

Winston Royce's 1970 paper is usually named as the start of Waterfall.

But Royce himself warned that the simple one-way version is risky, and suggested repeating steps and building early samples. The industry copied the simple diagram and ignored his warning. Lesson: read the original source.

Word help

sign off = formally approve a step before moving on

maintenance = fixing and improving software after it is in use

§3.2 When Waterfall works, and when it hurts

Slide L02-S08

Use it when

Watch out for

Requirements are clear and will not change much

Big decisions are made early, when we know the least

The system is safety-critical and needs full checks and documents

Working software appears only near the end

Software is part of a hardware project with a fixed schedule

Customers see the product too late to change it cheaply

A fixed contract needs an approved specification first

Problems are pushed to later and patched afterwards

Real-world example: final year projects and government tenders

A final year project where the proposal is approved in semester 7 and shown only at the end of semester 8. Often the team discovers too late that they built the wrong thing.

Many government IT projects in Pakistan are bought through tenders with a fixed specification, price and deadline. This pushes companies toward Waterfall even when requirements are not really stable. When the department changes its mind six months later, the result is change requests, cost disputes and delays.

Word help

safety-critical = a failure could hurt or kill people, e.g. aircraft or medical machines

tender = a formal offer to do a job for a fixed price, chosen by the buyer

§3.3 The V-model: plan the tests while you plan the system

Slide L02-S09

The V-model is a version of Waterfall used in safety-critical and regulated industries (cars, medical devices, defence). The left side goes down (planning and design); the right side goes up (testing). Each step on the left is checked by the matching test on the right.

Left side (plan and design)

Checked by (right side)

Requirements

Acceptance testing

System design

System testing

Detailed design

Unit and integration testing

Coding (bottom of the V)

—

Real-world example: car airbag

Requirement: "open within a fraction of a second after a crash."

The test for this requirement is planned on day one, not after coding. Car companies use the V-model for this reason.

The idea to keep, even if you never use a V-model: think about how you will test a requirement at the moment you write it down. If you cannot say how you would test it, the requirement is too unclear.

Word help

verify = check that something is correct

acceptance testing = the customer checks if the system is acceptable

§4 Incremental development

Slides L02-S10 to L02-S11

§4.1 Build in small pieces

Slide L02-S10

Start from an outline description. Then specification, development and validation are done together, again and again, producing Version 1, then Versions 2, 3, 4 ... until the final version. Unlike Waterfall, the activities are mixed and repeated with quick feedback.

Real-world example: WhatsApp grew one piece at a time

2009: launched as a simple app for showing your status next to contacts' names.

Then messaging; later groups and voice notes; later voice and video calls; recently channels and payments.

Each new piece was shaped by how people used the last version.

Incremental development is the base of agile methods (next lecture). It can also be planned: the pieces are decided in advance. For your semester project, Version 1 should be tiny, for example "a student can log in and see one screen".

Word help

increment = a small part that is added each time

version = one release of the software

§4.2 Benefits and problems

Slide L02-S11

Benefits

Problems

Changes cost less, because less work must be redone

Managers find it harder to see progress (fewer documents)

Users try real software, not long documents

The code gets messy as pieces are added, unless the team cleans it up (refactoring)

Useful software reaches users early

Hard for very large systems where many teams need a fixed structure early

Real-world example: a house that grows without a plan

A new room is added every few years without a plan. Each room is useful, but soon the stairs are in strange places and the wiring is a mess.

Code becomes like this without refactoring. This links to Lecture 1: software deteriorates as changes pile up.

Why would a national ID database struggle with only small increments? Many teams and many connections; security and data structure must be right from the start.

Word help

refactoring = cleaning up and improving code without changing what it does

visibility = how easily managers can see progress

§5 Integration and configuration (reuse)

Slides L02-S12

§5.1 Build less, reuse more

Slide L02-S12

1. Requirements: write the basic needs.

2. Search: find existing software that fits.

3. Adjust needs: change the requirements to match what exists.

4. Set up and connect: configure, join the parts, and add new code where needed.

Kind of reusable part

Example

Ready-made systems

Moodle set up for a university

Code libraries

Packages from PyPI or npm

Online services (APIs)

JazzCash payments, Google Maps

Real-world example: ready-made furniture

Buying ready-made furniture and arranging it in your room, instead of making every chair yourself. Faster and cheaper, but you get the sizes the shop has.

This is how most real software is built today. Very few teams write a login system, payment system or database from zero. The surprising step is adjust needs: customers accept it because it is faster, cheaper, less risky and already tested.

Disadvantages: the system may not fully meet real needs, and you lose control of the reused parts. If a company changes its price, drops a feature, or a library is abandoned, you inherit the problem. Remember Ariane 5 (Lecture 1): reusing code without re-checking its assumptions caused a disaster.

Word help

configure = set up the settings to fit your needs

integrate = join separate parts so they work together

API = a ready-made service your program can call, like a payment service

§6 The Spiral model and dealing with change

Slides L02-S13 to L02-S14

§6.1 Spiral: deal with the biggest risk first

Slide L02-S13

Created by Barry Boehm in 1988. Each loop of the spiral is one round of work and passes through four steps:

1. Set goals for this round.

2. Find and reduce risks, often by building a small test version (prototype).

3. Build and test the next piece.

4. Plan the next loop.

Before each round the team asks: what could go most wrong right now? They deal with that risk first. The spiral gets bigger as cost and commitment grow.

Real-world example: crop disease app

The biggest risk: can AI find diseases from cheap phone photos? Loop 1 tests only this, on 200 photos. If it fails, the team stops early and loses little.

Best for large, expensive, high-risk projects. Weakness: it needs people who are skilled at judging risk, and it is too heavy for small projects. Today Spiral is rarely used by name, but its idea (let risk decide what to do next) influenced later methods, including agile.

Word help

risk = something that might go wrong

prototype = a quick early sample version

§6.2 Every model is really an answer to change

Slide L02-S14

Why change is costly: one new requirement can mean new design, new code and new tests. Why change happens: competition, new laws (tax or data-protection rules), new technology, and users only discover what they really want when they see the software.

Strategy

How

Everyday example

Plan for change early

Build a prototype so users can react before the real work starts.

A tailor's trial fitting: he checks the sizes with you before final stitching.

Make change cheap

Deliver in small pieces, so a change only affects the pieces not built yet. (This is what Incremental development does.)

Changing a new restaurant's menu week by week instead of printing 10,000 fixed menus on day one.

Prototype type

Meaning

Throwaway prototype

Thrown away after learning. Built fast, without good structure or error handling.

Evolutionary prototype

Grows into the real product.

A common industry mistake

Shipping the throwaway prototype because "it already works". Throwaway prototypes should really be thrown away.

Connect the models: Waterfall mostly ignores change; Spiral plans for it through risk checks and prototypes; Incremental makes it cheap.

§7 Choosing a model

Slides L02-S15 to L02-S16

§7.1 Worked activity: choose the model

Slide L02-S15

For each project: choose a model, give two reasons, and name one risk your model handles badly. Model answers:

Project

Model

Two reasons

Weakness to watch

A. Crop-spraying drone (strict safety rules; hardware ready in 12 months)

Plan-driven: Waterfall or V-model

Safety approval needs full documents and planned tests; the hardware fixes the schedule.

Requirement mistakes are found late.

B. Farmer marketplace startup (founders unsure what farmers will use)

Incremental (agile)

Needs are unknown, so release a tiny version (e.g. list crops and call the buyer) and learn; cheap to change.

Code gets messy without refactoring.

C. UAF library catalogue and loans (good free systems exist)

Integration and configuration

Set up an existing free library system (Koha is widely used) instead of writing one: faster, cheaper, tested.

University rules may need to change to fit the software.

D. National tax system replacement (huge budget, new technology, big risk)

Spiral or a risk-driven mix

Test the riskiest parts first; review after each loop before spending more.

Heavy management work; needs risk experts.

Other answers can be correct if the reasons are good. The reasons matter more than the label.

§7.2 The four models side by side

Slide L02-S16

Waterfall

Incremental

Integration and configuration

Spiral

Requirements

Fixed at the start

Grow with each piece

Shaped by what exists

Improved each loop

Users see software

At the end

Early and often

Early, once set up

Samples each loop

Cost of change

High

Low

Depends on the product

Medium

Main strength

Control and documents

Feedback, flexibility

Speed, lower cost

Handles risk

Best for

Stable, safety-critical, fixed contracts

Business and web apps, unclear needs

Common needs with good existing products

Large, new, high-risk systems

Real projects often mix models: for example, a planned overall contract and system structure, with incremental development inside it, using ready-made parts. Many Pakistani software companies work like this for client projects. There is no best model, only the best fit for a project. Copy this table into your notes; it is likely exam material.

Summary

  • A process model is a general plan that teams change to fit their project.
  • Plan-driven and agile are two ends of a range. Most teams mix them.
  • Waterfall: good for stable, safety-critical work, but change is costly. The V-model pairs each design step with a test.
  • Incremental: change is cheap and users get software early, but code needs regular cleanup (refactoring).
  • Integration and configuration: reuse existing parts to save time, but you lose some control.
  • Spiral: deal with the biggest risk first.
  • Before Lecture 3: read Sommerville Ch. 2 (sections 2.1-2.3); write Assignment 2 (team process memo); read the Agile Manifesto at agilemanifesto.org.

Word bank

Word

Simple meaning

Example

software process

the steps a team actually follows

how your team really builds its project

process model

a general plan for building software

the Waterfall model

plan-driven

plan everything first, then follow the plan

building a motorway

agile

able to change direction quickly

a food delivery app updated every few weeks

sign off

formally approve before moving on

client signs the requirements document

maintenance

fixing and improving software after release

updating the portal for a new grading rule

safety-critical

failure could hurt or kill people

drone, airbag, pacemaker software

verify

check that something is correct

test that the airbag opens in time

acceptance testing

the customer checks if the system is acceptable

the client tries the system before paying

increment

a small part added each time

WhatsApp adding voice notes

refactoring

cleaning code without changing what it does

renaming confusing variables, removing repeated code

configure

set up settings to fit your needs

setting Moodle up for UAF courses

integrate

join parts so they work together

connecting your app to JazzCash payments

risk

something that might go wrong

AI cannot read cheap phone photos

prototype

a quick early sample version

paper screens of an app shown to farmers

throwaway prototype

a sample built only to learn, then discarded

a quick demo of a new screen layout

evolutionary prototype

a sample that grows into the real product

Version 1 of a startup app

memo

a short written note

Assignment 2's one-page process memo

Self-check questions

Try each question without looking. Then check your answer in the section shown.

#

Question

See

1

What is the difference between a software process and a process model? Use the biryani example.

§1.2

2

Plan-driven and agile are "a range, not two teams". Explain this sentence.

§2.1

3

List the five steps of the Waterfall model in order.

§3.1

4

Give two situations where Waterfall is a good choice, and two of its problems.

§3.2

5

In the V-model, which test checks the requirements step?

§3.3

6

How did WhatsApp show incremental development?

§4.1

7

Why does code get messy in incremental development, and what fixes it?

§4.2

8

What is the surprising step in integration and configuration, and why do customers accept it?

§5.1

9

Name the four steps of each loop of the Spiral model.

§6.1

10

What is the difference between a throwaway and an evolutionary prototype?

§6.2

11

Which model would you choose for a crop-spraying drone, and why?

§7.1

12

Copy the comparison table from memory: requirements, cost of change and best use for each model.

§7.2

Further reading

  • Sommerville, *Software Engineering*, 10th ed., Chapter 2, sections 2.1-2.3.
  • Pressman & Maxim, *Software Engineering: A Practitioner's Approach*, 8th ed., Chapter 4.1 (Prescriptive process models).
  • The Agile Manifesto: agilemanifesto.org (one page) - needed for Lecture 3.

← All SE-401 material