- Atlas
- Computer Science
- Requirements Engineering
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
- Formal Methods 1975-Present
- Structured Analysis 1975-1990
- Structured Analysis and Design Technique 1975-1990
- Jackson System Development 1979-1995
- Socio-Technical Requirements Engineering 1980-Present
- Structured systems analysis and design method 1981-2000
- Object-Oriented Analysis 1985-2000
- Environment-Machine Specification 1990-Present
- Use case 1992-Present
- Goal-Oriented Requirements Engineering 1993-Present
- Agent- and Actor-Oriented Modeling 1995-Present
- Model-Based Requirements Engineering 1995-Present
- Agile Requirements 2001-Present
- Specification by Example 2011-Present
- Requirements for AI and Data-Driven Systems 2015-Present
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
- Structured analysis (History, introduction), Wikipedia
- Data-flow diagram (introduction, History), Wikipedia
- Formal methods, Wikipedia
- Z notation (History), Wikipedia
- Use case (History, introduction), Wikipedia
- Unified Modeling Language, Wikipedia
- Axel van Lamsweerde, Wikipedia
- KAOS (software development), Wikipedia
- 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.
- 1975-Present
Formal Methods
How can specifications be made mathematically precise and checkable?
- 1975-1990
- 1975-1990
Structured Analysis and Design Technique
How can system activities be modelled as constrained boxes?
- 1979-1995
Jackson System Development
How should software mirror the structure of the problem?
- 1980-Present
Socio-Technical Requirements Engineering
How do requirements depend on organization and work practice?
- 1981-2000
Structured systems analysis and design method
What fixed stages should analysis and design follow?
- 1985-2000
Object-Oriented Analysis
How should a system be modelled as interacting objects?
- 1990-Present
Environment-Machine Specification
Where is the boundary between system and world?
- 1992-Present
- 1993-Present
Goal-Oriented Requirements Engineering
Why does a stakeholder want what they ask for?
- 1995-Present
Agent- and Actor-Oriented Modeling
How do autonomous agents reconcile their goals?
- 1995-Present
Model-Based Requirements Engineering
How can requirements be expressed as checkable models?
- 2001-Present
Agile Requirements
How can requirements evolve through continuous conversation?
- 2011-Present
Specification by Example
What concrete example shows a requirement is met?
- 2015-Present
Requirements for AI and Data-Driven Systems
How should requirements be set for data-driven and AI systems?
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.
Environment-Machine Specification influenced by Formal Methods
The formal-methods tradition's demand for a precise boundary between specification and world informed Jackson and Zave's environment-machine distinction, which recast requirements as statements about the environment rather than the machine.
Carried by Michael Jackson; Pamela Zave.
Structured Analysis and Design Technique rival of Structured Analysis
DeMarco's data-flow structured analysis and Ross's SADT were contemporaneous, competing diagrammatic methods for modelling systems in the 1970s; both were taught as systems-analysis approaches and vied for the same analyst audience.
Carried by Tom DeMarco; Douglas Ross.
Jackson System Development reacted against Structured Analysis
Jackson's JSD defined itself against function-and-data decomposition: it began from real-world entities and their time-ordered events rather than data flows, arguing that structured analysis could not model behaviour over time.
Carried by Michael Jackson; Jackson System Development (1983).
Structured systems analysis and design method grew out of Structured Analysis
SSADM, the UK government-backed method, built on the data-flow-diagram and data-dictionary conventions of structured analysis, adding prescribed stages and documentation to make it a full public-sector method.
Object-Oriented Analysis replaced Structured Analysis
Object-oriented analysis replaced the function-and-data-flow decomposition of structured analysis with objects carrying both attributes and behaviour, arguing that the same objects should persist from analysis through design to code.
Carried by Grady Booch; Peter Coad.
Model-Based Requirements Engineering grew out of Structured Analysis
Model-based requirements engineering generalized the diagrammatic tradition of structured analysis, expressing requirements as checkable models from which code or tests can be generated, and later drawing on UML.
Model-Based Requirements Engineering influenced by Object-Oriented Analysis
The UML unification of object-oriented notations supplied model-based requirements engineering with its standard semi-formal languages, such as state machines and activity diagrams, for expressing and checking requirements.
Carried by Unified Modeling Language.
Agent- and Actor-Oriented Modeling grew out of Goal-Oriented Requirements Engineering
Agent- and actor-oriented modelling extended goal-oriented analysis to systems of autonomous interacting components, treating software agents and human actors as first-class elements whose goals and dependencies must be reconciled.
Specification by Example grew out of Agile Requirements
Specification by example grew out of agile requirements and behavior-driven development, answering the agile deferral of detail with concrete executable acceptance examples that serve as both specification and test.
Carried by Gojko Adzic; Specification by Example (2011).
Object-Oriented Analysis influenced by Jackson System Development
JSD's insistence that program structure mirror the structure of the problem domain, modelling real-world entities and events, fed into object-oriented analysis's practice of modelling problem-domain entities as objects.
Carried by Michael Jackson.
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.
Socio-Technical Requirements Engineering influenced by Socio-Technical Systems Theory in Work And Labor
Socio-Technical Systems Theory, from the Tavistock Institute's studies of work organisation, is the direct source of socio-technical requirements engineering. Its concept of jointly optimising social and technical subsystems was taken up by requirements researchers applying it to information systems.
Carried by Eric Trist; Fred Emery.
Structured systems analysis and design method influenced by Structured analysis in Systems Analysis And Design
SSADM incorporated the data-flow and data-dictionary techniques of structured analysis as its central analysis notation. The UK method standardised those techniques for public-sector information systems development.
Structured systems analysis and design method influenced by Structured Analysis in Software Architecture
SSADM was assembled from the structured-analysis data-flow modelling tradition, adopting its process and data-flow diagrams as core products. The method's analysis stages are a codified version of structured analysis for UK government projects.
Object-Oriented Analysis influenced by Structured analysis in Systems Analysis And Design
Object-oriented analysis methods such as Coad and Yourdon's and Rumbaugh's OMT were built as successors to structured analysis, reusing its data-flow and functional decomposition views while wrapping them in object concepts. The OOA literature explicitly contrasts its models with the data flow diagrams and data dictionaries of structured analysis.
Carried by Peter Coad; Edward Yourdon; James Rumbaugh.
Object-Oriented Analysis influenced by Object-oriented programming in Programming Paradigms
Object-oriented analysis took the object, class and inheritance concepts of object-oriented programming, including the Simula and Smalltalk lineage, and applied them at the analysis level. The analysis methods were explicitly modelled on the programming paradigm.
Carried by Sally Shlaer; Stephen Mellor; Grady Booch.
Object-Oriented Analysis influenced by Structured Analysis in Software Architecture
Object-oriented analysis was developed as a successor to structured analysis, keeping its functional and data views while reorganising them around objects. The OOA texts of the early 1990s present their models as replacements for structured analysis data flow diagrams.
Carried by Peter Coad; Edward Yourdon.
Object-Oriented Analysis influenced by Object-oriented programming in Software Engineering
Object-oriented analysis was created to bring the object concepts of object-oriented programming (encapsulation, inheritance, objects and classes) into the requirements and analysis phase. Its makers, such as Shlaer and Mellor and Coad and Yourdon, took the programming paradigm's vocabulary and applied it to analysis models.
Carried by Sally Shlaer; Stephen Mellor; Peter Coad.
Object-Oriented Analysis led to Object-Oriented Modeling in Model Based Systems Engineering
Object-oriented modeling in MBSE grew directly out of object-oriented analysis methods (Booch, Rumbaugh, Jacobson), which were unified into UML in 1997 and carried into systems modeling.
Carried by Grady Booch; James Rumbaugh; Ivar Jacobson.
Model-Based Requirements Engineering grew out of Model-Based Systems Engineering in Systems Engineering
Model-based requirements engineering grew directly out of model-based systems engineering, applying its system models and modelling languages to the requirements phase. MBSE's integration of requirements with architecture models is the basis of MBRE.
Agile Requirements grew out of Agile software development in Systems Analysis And Design
Agile requirements practices grew directly out of the Agile software development movement, whose 2001 Manifesto and its authors (Beck, Cockburn, Highsmith) framed working software and customer collaboration over comprehensive documentation, which agile requirements then elaborated into user stories, backlogs and on-site customers.
Carried by Kent Beck; Alistair Cockburn; Manifesto for Agile Software Development (2001).
Specification by Example grew out of Extreme Programming in Software Process Models
Specification by Example is a refinement of Extreme Programming's test-first and on-site-customer practices, especially the acceptance-test-driven development promoted within XP and its story-card planning.
Carried by Kent Beck; Extreme Programming Explained (1999).
Specification by Example grew out of Test-driven development in Software Testing
Specification by Example grew directly out of test-driven development and its acceptance-test variant; Gojko Adzic's 2011 book synthesized practices from teams using executable acceptance criteria in the TDD tradition, notably the Cucumber/FitNesse lineage.
Carried by Gojko Adzic; Specification by Example (2011).

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 EngineeringRelated fields
Fields its ideas are linked to
- Systems Analysis And Design 8 links
- Model Based Systems Engineering 8 links
- Systems Engineering 6 links
- Software Architecture 4 links
- Software Engineering 3 links
- Information Systems 2 links
- Systems Verification 2 links
- Data Modeling 1 link
- Signals And Systems 1 link
- Human Resources 1 link
- Enterprise Architecture 1 link
- Enterprise Systems 1 link
More in Software Engineering
- Computing Education
- Design Patterns
- Devops And Sre
- Formal Methods
- Open Source Software
- Software Architecture
- Software Engineering
- Software Evolution
- Software Process Models
- Software Testing
See where Requirements Engineering sits on the Map of Human Knowledge