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.