Phase 1 of 5  ·  Foundations
Week 02 / 20   ·   Ch 2

Software
Process Models

"Waterfall vs. Agile vs. Spiral — which one fits YOUR project?"

📚 Ch 2 — Software Processes🔄 3 Process Models📋 4 Process Activities⏱ ~20 min read

🔍Concept Deep Dives

Click each concept to expand — real examples, diagrams, pros & cons.

💧

Waterfall Model

Sequential phases: Requirements → Design → Implementation → Testing → Maintenance. Move down, never up.

When to Use

Requirements are well-understood upfront. Safety-critical systems. Fixed contracts.

Real-World Example

Defense systems, medical device firmware, large government contracts where requirements are locked.

✓ Advantages

  • Easy to manage — clear phase boundaries
  • Good for stable, well-understood requirements
  • Strong documentation

⚠ Watch Out

  • Inflexible to change
  • Customer only sees product at the end
  • Late discovery of problems = expensive fixes
Waterfall — sequential, phase-gated
1RequirementsLock down what the system must do.
2DesignPlan the architecture and components.
3ImplementationWrite the code.
4TestingVerify it against the requirements.
5MaintenanceFix and update after release.
Each phase finishes before the next begins — going back is expensive.
🔁

Incremental Development

Develop the system in increments. Each increment delivers a working slice of functionality.

When to Use

Requirements likely to change. Customer needs early delivery. Internet-based systems.

Real-World Example

Spotify — shipped a minimal music player first, then added playlists, recommendations, podcasts incrementally.

✓ Advantages

  • Early value delivery
  • Easier to accommodate change
  • Customer feedback improves each increment

⚠ Watch Out

  • Process less visible (no clear phases)
  • Structure degrades without refactoring
  • Hard to manage large teams
Incremental — build in working slices
1Initial versionShip a minimal working slice.
2Intermediate versionsAdd functionality from user feedback.
3Final versionMature product after several increments.
Feedback loop on every increment
♻️

Reuse-Oriented Engineering

Base the system on integrating existing components — COTS, open-source, services.

When to Use

Suitable components exist. Budget-constrained. Faster time-to-market needed.

Real-World Example

A startup building a SaaS app: uses Stripe (payments), Auth0 (auth), Twilio (SMS) — all existing services.

✓ Advantages

  • Reduced cost and risk
  • Faster delivery
  • Battle-tested components

⚠ Watch Out

  • Loss of control over evolution
  • Components may not fit exactly
  • Security risk from third-party dependencies
Reuse-oriented — integrate existing components
1Component analysisFind existing components that fit the requirements.
2Requirements modificationAdjust requirements to what's available.
3Design with reuseArchitect the system around those components.
4Development & integrationBuild the glue and wire it together.
🌀

4 Process Activities

Every software process — regardless of model — contains these 4 core activities.

When to Use

Always applicable — waterfall runs them sequentially, agile interleaves them.

Real-World Example

Even a solo weekend project: you decide what to build (spec), write it (dev), test it (validate), then update it (evolve).

✓ Advantages

  • Universal framework for understanding any process
  • Maps to team roles and responsibilities

⚠ Watch Out

  • Oversimplification — real projects are messier
The 4 universal process activities
1SpecificationWhat should it do?
2DevelopmentBuild it.
3ValidationDoes it work?
4EvolutionChange it over time.
Waterfall runs these in sequence; agile interleaves them every iteration.

📋Quick Reference

θ Ch 2 Cheat Sheet — Software Process Models
Waterfall
Sequential phases, no going back. Good for: stable requirements, safety-critical systems.
Incremental
Build in slices, deliver early value. Good for: changing requirements, internet services.
Reuse-Oriented
Compose from existing components/services. Good for: budget-constrained, faster delivery.
4 Process Activities
Specification, Development, Validation, Evolution — in every process model.
Plan-driven
All activities planned upfront. Process document guides work. Waterfall is plan-driven.
Agile
Incremental, interleaved planning and execution. Designed for fast change.
Process Improvement
CMMI levels 1-5. Mature processes = higher quality, more predictable delivery.
θ
Sommerville's Key Points — Ch 2
Author's own summary from the end of the chapter.
  • 1Software processes are the coherent sets of activities for producing a software system.
  • 2Waterfall: plan-driven, sequential phases. Good for stable requirements.
  • 3Incremental development: interleaves specification, development, validation. Cheaper to accommodate changes.
  • 4Reuse-oriented: based on systematic reuse. Reduces development costs and risks but may not meet exact user needs.
  • 5All processes include: specification, development, validation, and evolution.
  • 6Process improvement: CMMI framework measures process maturity on a 5-level scale.

🌍From the Book & Beyond

📖

Case Study — The Waterfall Model (Royce, 1970)

Sommerville traces waterfall — the first published software process model — to engineering processes used in large military systems (Royce, 1970). Each stage produces documents that are "signed off" before the next phase starts, from requirements definition down to operation and maintenance, normally the longest phase of all. The classic failure mode: teams prematurely freeze the specification, so the finished system won't do what users want and design flaws get patched with implementation tricks. Sommerville says waterfall really fits only embedded systems, critical systems needing up-front safety analysis, and large multi-company projects.

2026 Perspective — CI/CD Ate the Process Diagram

The dominant process in 2026 isn't in this chapter by name: trunk-based development plus CI/CD, where every commit is automatically built, tested, and often deployed — incremental development pushed to its logical extreme, with releases measured in hours, not months. But Sommerville's plan-driven vs. incremental split still earns its keep: avionics, medical devices, and multi-vendor government contracts still demand signed-off specifications. So most real organizations run hybrids — plan-driven at the architecture and compliance level, continuous delivery inside the team. Knowing when each fits is the actual skill.

🧠Quiz — Test Yourself

Think through your answer first, then reveal.

Q1
Recall
When would you choose Waterfall over Incremental? Give a real-world example.
Waterfall: when requirements are stable and well-understood upfront — e.g., building firmware for a pacemaker. You can't ship 'increments' of a medical device. Regulatory approval requires documented sequential phases.
Q2
Apply
What is the biggest disadvantage of incremental development for large teams?
Process visibility — management can't easily see how far along you are without running the software. Also, system structure degrades over time as increments are added without refactoring, making the system harder to change.
Q3
Analyze
Name 3 real-world examples of reuse-oriented software engineering in a modern startup.
Stripe for payments, Auth0 for authentication, Twilio for SMS/email, SendGrid for email, AWS S3 for storage, Firebase for real-time database, GitHub Actions for CI/CD.
Up Next → Week 03
Agile Software Development
Agile is NOT just standup meetings. Here's what it actually means.
Continue → Week 03