Requirements Engineering

Requirements engineering is the part of software engineering that decides what a system should do before and while it is built.

15 frameworks, from 1975 to today · Software Engineering · Computer Science

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

Overview

Requirements engineering is the part of software engineering that decides what a system should do before and while it is built. It covers finding out what the people who will use or pay for a system actually need, writing that down in a form builders can act on, checking that the description is right, and managing how it changes. The stakes are high because most large software failures are not coding failures: the program does what it was told, but it was told the wrong thing. Getting requirements wrong is cheap to fix on paper and ruinously expensive to fix in code, so the field's history is a long argument about how to make the description of a system precise, complete, and agreed—and about how much of that description can ever be pinned down in advance.

Systems analysis and the data-flow tradition

Requirements engineering grew out of "systems analysis," a practice that emerged in the 1960s and 1970s as organizations began building large business information systems. The dominant early technique was Structured Analysis, developed most influentially by Tom DeMarco in Structured Analysis and System Specification (1978)1. Its central device was the data-flow diagram: a picture of processes, data stores, and the flows between them, showing what the system does to data without committing to how it is coded2. Structured analysis was paired with a data dictionary (a precise catalogue of every data element) and with structured design, which turned the analysis into a module structure12. The appeal was that a non-programmer could read a data-flow diagram and confirm it, so the analyst could serve as a bridge between the business and the programmers.

A parallel and more elaborate tradition came from Douglas Ross at MIT, whose Structured Analysis and Design Technique (SADT), developed from the late 1960s and published in the 1970s, modelled a system as a hierarchy of boxes and arrows, with each activity constrained by inputs, controls, outputs, and mechanisms. SADT's disciplined "read the diagram aloud" review method influenced later notations, and it was standardized commercially as IDEF0 in the 1980s. In the United Kingdom, a government-backed method called SSADM (Structured Systems Analysis and Design Method) was mandated for public-sector IT projects from the early 1980s; it prescribed a fixed sequence of analysis stages and became a standard fixture of British computing training.

The limitation these methods shared was that they modelled functions and data but not the behaviour over time of the things in the world the system was about. Michael Jackson's Jackson System Development (JSD), developed at the end of the 1970s and published in 1983, attacked this directly: it began by modelling the real-world entities and the time-ordered events that happen to them, then derived the software from that model. JSD's insistence that the structure of the program should mirror the structure of the problem was an early statement of a theme that would return repeatedly.

Formal specification and the drive for precision

Alongside the diagrammatic tradition ran a mathematically minded one. Formal methods hold that a specification should be written in a language with precise, checkable meaning—typically based on logic or set theory—so that it can be analysed and even proven to satisfy properties before code exists3. The Vienna Development Method (VDM), developed at IBM's Vienna laboratory in the 1970s, and Z, developed at Oxford in the late 1970s and 1980s, were the landmark specification languages. A Z specification describes a system as a collection of state schemas and operations with pre- and post-conditions, allowing a reviewer to reason about consistency4. The approach produced notable successes—Z was used in the specification of a safety-critical signalling system for London's Docklands Light Railway—but it demanded mathematical training and struggled to scale to ordinary business software, so it remained a specialist tool for safety- and security-critical domains.

A related strand asked a sharper question: what exactly is the boundary between the system and its surroundings? Environment-machine specification treats the system as a machine and the world it lives in as its environment, and insists that requirements are statements about the environment, not about the machine. This distinction—between what the world must be like and what the software must do—was articulated influentially by Michael Jackson and Pamela Zave in the 1990s and became foundational to later work on problem frames and on the meaning of "requirement" itself.

Objects, use cases, and the turn to the user

The 1980s brought object-oriented programming, and with it object-oriented analysis: instead of decomposing a system by function, analysts modelled it as a set of objects with attributes and behaviour, mirroring the entities of the problem domain. Grady Booch, Peter Coad, and others published competing methods, and the approach's promise was that the same objects would carry through from analysis to design to code, reducing the translation loss between stages.

The most consequential shift of the early 1990s was Ivar Jacobson's use case modeling, introduced with his book Object-Oriented Software Engineering (1992)5. A use case is a description of a sequence of interactions between an outside actor and the system that yields a result of value to that actor5. Use cases reframed requirements around user goals rather than system functions, and they were readable by customers. They were absorbed into the Unified Modeling Language (UML) in the late 1990s, which unified the notation of Booch, Jacobson, and James Rumbaugh and made use-case diagrams and class diagrams standard currency in industry56.

The same period saw goal-oriented requirements engineering, which asks not just what the system shall do but why—what goal the stakeholder is trying to achieve and what alternatives exist. Work by Axel van Lamsweerde and others from the early 1990s, and later the KAOS and i* frameworks, modelled goals, their refinement into sub-goals, and the conflicts between them, so that design choices could be justified against stakeholder intent78. Agent- and actor-oriented modeling extended this to systems of autonomous, interacting components, treating both software agents and human actors as first-class elements whose goals and dependencies must be reconciled.

Agile requirements and the reaction against big up-front specification

By the late 1990s the heavyweight, document-driven process—epitomized by the waterfall model and its requirement-sign-off gates—was under attack. The Agile Manifesto of 2001 declared working software over comprehensive documentation and responding to change over following a plan9. In requirements terms this meant abandoning the attempt to specify everything in advance. Instead, requirements arrived as user stories—short, conversational statements of a need from a user's perspective—and as backlog items prioritized continuously. The role of the requirements document was replaced by ongoing conversation with a customer representative, and detail was deferred until the last responsible moment.

This created a genuine tension with the older tradition, and the field's response was not to abandon rigor but to relocate it. Specification by example, popularized by Gojko Adzic's book of that name (2011) and central to behavior-driven development, captures requirements as concrete, executable examples—an acceptance test written before the code—so that the specification and the test are the same artifact. The question "what does 'done' mean?" is answered with a runnable example rather than a paragraph.

Model-based and socio-technical requirements

Model-based requirements engineering generalizes the diagrammatic tradition: requirements are expressed as models (state machines, activity diagrams, formal or semi-formal notations) that can be checked for consistency and from which code or tests can be generated. It descends directly from structured analysis and the UML, and it underpins safety-critical practice, where standards such as those for automotive and avionics software require traceable models.

Running alongside all of this is socio-technical requirements engineering, which insists that a system's requirements cannot be separated from the organization, people, and work practices it will be embedded in. Its roots go back to the Tavistock Institute's studies of coal mining in the 1950s, which showed that technical and social systems must be designed together. In software terms it means that a requirement is not just a function but a change to how people work, and that ignoring the organizational context is a leading cause of systems that are technically correct and practically rejected.

The present: data, AI, and the persistence of the old questions

The newest frontier is requirements for AI and data-driven systems. Machine-learned components do not have a fixed specification that can be written down and verified; their behaviour depends on training data, and their correctness is statistical rather than absolute. This has forced the field to revisit its oldest questions in new form: how do you state a requirement for a system whose behaviour you cannot fully predict? How do you specify fairness, robustness, or acceptable error rates? The answers draw on the whole history—goal models to capture intent, use cases to frame interactions, formal methods for the parts that can be pinned down, and iterative, example-driven practice for the parts that cannot.

Today the field is plural. Formal specification survives in safety- and security-critical work; model-based methods dominate regulated industries; agile stories and specification by example dominate product software; and socio-technical analysis is increasingly recognized as essential wherever software reshapes how people work. The open questions are old ones in new dress: how much can be known before building begins, how to keep a specification honest as the world changes, and how to write down a requirement for a system that learns.

References

  1. Structured analysis (History, introduction), Wikipedia
  2. Data-flow diagram (introduction, History), Wikipedia
  3. Formal methods, Wikipedia
  4. Z notation (History), Wikipedia
  5. Use case (History, introduction), Wikipedia
  6. Unified Modeling Language, Wikipedia
  7. Axel van Lamsweerde, Wikipedia
  8. KAOS (software development), Wikipedia
  9. Agile software development, Wikipedia

The frameworks of Requirements Engineering

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

  1. 1975-Present

    Formal Methods

    How can specifications be made mathematically precise and checkable?

    Fly to its tower in Nousfarer

  2. 1975-1990

    Structured Analysis

    How can a system's data flows be modelled readably?

    Fly to its tower in Nousfarer

  3. 1975-1990

    Structured Analysis and Design Technique

    How can system activities be modelled as constrained boxes?

    Fly to its tower in Nousfarer

  4. 1979-1995

    Jackson System Development

    How should software mirror the structure of the problem?

    Fly to its tower in Nousfarer

  5. 1980-Present

    Socio-Technical Requirements Engineering

    How do requirements depend on organization and work practice?

    Fly to its tower in Nousfarer

  6. 1981-2000

    Structured systems analysis and design method

    What fixed stages should analysis and design follow?

    Fly to its tower in Nousfarer

  7. 1985-2000

    Object-Oriented Analysis

    How should a system be modelled as interacting objects?

    Fly to its tower in Nousfarer

  8. 1990-Present

    Environment-Machine Specification

    Where is the boundary between system and world?

    Fly to its tower in Nousfarer

  9. 1992-Present

    Use case

    What interactions give an outside actor value?

    Fly to its tower in Nousfarer

  10. 1993-Present

    Goal-Oriented Requirements Engineering

    Why does a stakeholder want what they ask for?

    Fly to its tower in Nousfarer

  11. 1995-Present

    Agent- and Actor-Oriented Modeling

    How do autonomous agents reconcile their goals?

    Fly to its tower in Nousfarer

  12. 1995-Present

    Model-Based Requirements Engineering

    How can requirements be expressed as checkable models?

    Fly to its tower in Nousfarer

  13. 2001-Present

    Agile Requirements

    How can requirements evolve through continuous conversation?

    Fly to its tower in Nousfarer

  14. 2011-Present

    Specification by Example

    What concrete example shows a requirement is met?

    Fly to its tower in Nousfarer

  15. 2015-Present

    Requirements for AI and Data-Driven Systems

    How should requirements be set for data-driven and AI systems?

    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.

Formal MethodsStructured AnalysisStructured Analysis and Design Techni…Jackson System DevelopmentSocio-Technical Requirements Engineer…Structured systems analysis and desig…Object-Oriented AnalysisEnvironment-Machine SpecificationUse caseGoal-Oriented Requirements EngineeringAgent- and Actor-Oriented ModelingModel-Based Requirements EngineeringAgile RequirementsSpecification by ExampleRequirements for AI and Data-Driven S…

Beyond the field

Where Requirements Engineering's ideas came from in other fields, and what they led to there: the strongest 12 of 50 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.

Requirements Engineering is a planet in Nousfarer

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

Land on Requirements Engineering

Related fields

Fields its ideas are linked to

More in Software Engineering

See where Requirements Engineering sits on the Map of Human Knowledge