Software Process Models

Software process models are the frameworks a team uses to organize the making of software: what happens in what order, who does it, what gets written down, and how the work is checked and changed.

11 frameworks, from 1968 to today · Software Engineering · Computer Science

still a working view ended · each leads to its entry below

Overview

Software process models are the frameworks a team uses to organize the making of software: what happens in what order, who does it, what gets written down, and how the work is checked and changed. The stakes are practical. A program of a few hundred lines can be built by one person in an afternoon, but a banking system or an air-traffic network takes years, many people, and constant revision. The process model is the answer to the question of how to keep such work from collapsing under its own complexity. The history of these models is a history of competing answers—each one a reaction to the failures of the last.

The software crisis and the first life-cycle models

Through the 1950s and early 1960s, most software was written ad hoc, often by the same people who ran the hardware. As systems grew, projects ran late, over budget, and unreliable. A 1968 NATO conference in Garmisch, Germany, gave the problem a name—the "software crisis"—and the term "software engineering" entered circulation. The first response was to borrow the discipline of large construction and manufacturing: define the stages of building a system and move through them in order.

The software development life cycle (SDLC) is the general idea that software passes through phases—requirements, design, implementation, testing, deployment, maintenance—and that managing the transitions between them is as important as the coding. The best-known concrete form is the Waterfall Model, usually credited to Winston Royce's 1970 paper "Managing the Development of Large Software Systems." Royce drew the phases as a cascade flowing downward, and the image stuck. It is worth noting that Royce himself warned the pure cascade was "risky and invites failure"; he recommended iterating back to earlier phases. The simplified version—finish each phase before starting the next, with no going back—became the standard prescription of the 1970s and 1980s, especially in defense and government contracting, where fixed requirements and milestone reviews suited the procurement process. Its appeal was control: each phase produced documents that could be reviewed and signed off, and progress could be measured against a plan.

Iteration and risk: the spiral and incremental approaches

Waterfall's weakness showed up on projects where requirements were uncertain or changed. By the time testing began, the design was frozen, and discovering a misunderstanding meant expensive rework. In the 1980s, a countercurrent grew: build the system in increments, and revisit earlier decisions.

Barry Boehm's Spiral Model, published in 1986 and refined in 1988, made risk the organizing principle12. The project proceeds in loops; each loop begins by identifying the riskiest remaining unknowns, then builds a prototype or partial product to resolve them, then plans the next loop. A team building a new transaction system might spend its first spiral proving that the database can handle the expected load before committing to a full design. The spiral combined the discipline of phased development with the flexibility of prototyping, and it introduced explicit risk analysis as a first-class activity1.

Around the same time, incremental and evolutionary delivery gained ground: ship a working subset, learn from it, extend it1. These ideas set the stage for the 1990s, when object-oriented methods and a new generation of process frameworks arrived1.

Process maturity and the Capability Maturity Model

A parallel strand asked not how to sequence work but how to improve an organization's process over time. The Capability Maturity Model (CMM), developed at the Software Engineering Institute at Carnegie Mellon University from the late 1980s (the first version appeared around 1991), rated an organization's process on five levels: initial, repeatable, defined, managed, and optimizing. The premise was that a chaotic process produces unpredictable results, while a measured, documented one can be improved. CMM assessments became a requirement for many defense contractors, and the model was later generalized into CMMI (Capability Maturity Model Integration). Its critics argued that heavy documentation could become an end in itself, but the underlying insight—that process quality can be measured and raised—shaped how large organizations thought about software for a decade.

The Rational Unified Process and use-case-driven development

In the late 1990s, Grady Booch, Ivar Jacobson, and James Rumbaugh—the "three amigos" behind the Unified Modeling Language—packaged their methods into the Rational Unified Process (RUP), commercialized by Rational Software. RUP organized development into four phases (inception, elaboration, construction, transition) and iterated within them, with use cases driving requirements and architecture. It was explicitly iterative and architecture-centric, and it came with extensive templates and roles. RUP's weight and formality made it popular in large enterprises, but its sheer volume of artifacts also made it a target for the lighter methods that followed.

Agile: a reaction and a movement

By the late 1990s, a cluster of lightweight methods had emerged—among them Kent Beck's Extreme Programming (XP), Scrum, Crystal, and feature-driven development3. XP, articulated by Beck around 1999, pushed practices to extremes: pair programming, test-first development, continuous integration, and short release cycles. Scrum, drawing on work by Jeff Sutherland and Ken Schwaber in the early 1990s, organized work into short "sprints" with a prioritized backlog and daily stand-up meetings.

In February 2001, seventeen of these practitioners met at a ski resort in Snowbird, Utah, and published the Agile Manifesto, valuing individuals and interactions over processes and tools, working software over comprehensive documentation, customer collaboration over contract negotiation, and responding to change over following a plan. Agile did not reject process; it relocated it—into short iterations, continuous feedback, and self-organizing teams. Its supporters found it convincing because it matched how good developers actually worked on uncertain problems; its critics worried it could excuse poor planning or scale badly. Both concerns drove the next two decades of work.

From continuous delivery to DevOps

Agile focused on development; the operations side—deploying, running, and monitoring systems—remained a bottleneck. Continuous delivery, described in Jez Humble and David Farley's 2010 book of that name, extended the idea of short cycles to release: keep the software always in a deployable state, automate the build-test-release pipeline, and ship small changes frequently. Continuous integration (merging and testing code many times a day) and continuous deployment (automatically releasing passing builds) are its close relatives.

DevOps, a term popularized around 2009, named the collaboration between development and operations teams that continuous delivery required4. It combined cultural change (shared responsibility for running systems), automation (infrastructure as code, automated pipelines), and measurement (monitoring and feedback)4. The through-line from the 1970s is visible: each step shortened the loop between deciding to change something and learning whether the change worked.

Where the field stands

Today no single model dominates. Waterfall survives where requirements are genuinely fixed and contracts demand it; the spiral's risk-driven iteration lives on in modern incremental planning; CMMI persists in organizations that need formal process assessment. Agile in its Scrum and Kanban forms is the default in much of the industry, and continuous delivery and DevOps are standard practice for teams that ship frequently. The open questions are the old ones in new clothes: how to scale agile practices to very large, regulated systems; how to balance speed with safety and security; and how to measure whether a process actually helps, rather than merely being followed. The history suggests the answer will keep shifting as the systems themselves grow more complex.

References

  1. Software development process (Examples, History), Wikipedia
  2. Spiral model (History), Wikipedia
  3. Agile software development (History), Wikipedia
  4. DevOps (History, introduction), Wikipedia

The frameworks of Software Process Models

Each framework is a way of working the field has used: when it held, and the question it answers.

  1. 1968-Present

    Systems development life cycle

    What stages does building software pass through?

    Fly to its tower in Nousfarer

  2. 1970-2000

    Waterfall Model

    Should each phase be finished before the next?

    Fly to its tower in Nousfarer

  3. 1980-Present

    Incremental build model

    Can we ship a working part and extend it?

    Fly to its tower in Nousfarer

  4. 1986-2005

    Spiral Model

    How do we manage risk in a big project?

    Fly to its tower in Nousfarer

  5. 1991-2010

    Capability Maturity Model

    How can an organization improve its process over time?

    Fly to its tower in Nousfarer

  6. 1995-Present

    Scrum

    How do we organize short, repeated work cycles?

    Fly to its tower in Nousfarer

  7. 1998-2010

    Rational Unified Process

    How do we structure iterative, use-case-driven development?

    Fly to its tower in Nousfarer

  8. 1999-Present

    Extreme Programming

    What practices make frequent feedback possible?

    Fly to its tower in Nousfarer

  9. 2001-Present

    Agile Software Development

    How do we respond to change rather than freeze plans?

    Fly to its tower in Nousfarer

  10. 2009-Present

    DevOps

    How do development and operations work together?

    Fly to its tower in Nousfarer

  11. 2010-Present

    Continuous Delivery

    How do we keep software always ready to release?

    Fly to its tower in Nousfarer

How the ideas connect

Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.

Systems development life cycleWaterfall ModelIncremental build modelSpiral ModelCapability Maturity ModelScrumRational Unified ProcessExtreme ProgrammingAgile Software DevelopmentDevOpsContinuous Delivery

Beyond the field

Where Software Process Models's ideas came from in other fields, and what they led to there: the strongest 12 of 59 links.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

Software Process Models is a planet in Nousfarer

Its city has a tower for each of these 11 frameworks. Land, walk in, and climb one concept at a time.

Land on Software Process Models

Related fields

Fields its ideas are linked to

More in Software Engineering

See where Software Process Models sits on the Map of Human Knowledge