- Atlas
- Computer Science
- Software Engineering
Software Engineering
Software engineering is the discipline of building software that is large, long-lived, and made by teams rather than individuals.
14 frameworks, from 1968 to today · Software Engineering · Computer Science
- Structured Programming 1968-1985
- Formal Methods 1969-Present
- Software Testing and Verification 1970-Present
- Structured Design 1970-1990
- Waterfall Model 1970-1995
- Software Testing 1975-Present
- Object-oriented programming 1980-Present
- Capability Maturity Model 1987-2010
- Spiral Model 1988-2005
- Component-based software engineering 1995-2015
- Agile Software Development 1999-Present
- Model-Driven Engineering 2001-2015
- DevOps and Continuous Delivery 2009-Present
- Continuous Delivery 2010-Present
Overview
Software engineering is the discipline of building software that is large, long-lived, and made by teams rather than individuals. Its central problem is not writing code but managing complexity: a program of a few hundred lines can be held in one person's head, while a system of millions of lines, built over years by people who come and go, cannot. The field's history is a sequence of attempts to make such systems reliable, affordable, and changeable—through process models, design methods, programming disciplines, testing regimes, and, increasingly, automation. What follows traces how practitioners came to think about that problem, from the "software crisis" of the 1960s to the continuous-delivery pipelines of today.
The software crisis and the birth of a discipline
In the 1950s and early 1960s, computing was dominated by hardware. Programs were written by the same people who designed the machines, often in assembly language, and were typically small and bespoke. As computers spread into business and government in the 1960s, projects grew enormous—the US Air Force's SAGE air-defense system, IBM's OS/360 operating system—and so did the failures. Projects ran over budget, shipped late, and were riddled with defects1. In 1968 the NATO Science Committee convened a conference in Garmisch, Germany, and the organizers deliberately coined the term "software engineering" to provoke the assembled programmers into treating their work as an engineering discipline rather than a craft. The phrase named a problem more than a solution: how to make software development predictable2.
The first answers came from structured programming. In 1968 the Dutch computer scientist Edsger Dijkstra published a short letter, "Go To Statement Considered Harmful," arguing that unrestricted jumps made programs hard to reason about. The constructive alternative, developed through the late 1960s and 1970s by Dijkstra, C. A. R. Hoare, and others, held that any program could be written using only three control structures—sequence, selection (if-then-else), and iteration (loops)—and that programs should be built top-down, decomposed into small procedures each with a single entry and exit. The payoff was comprehensibility: a reader could follow the flow of control without tracing jumps across the page. Structured programming became the orthodoxy of the 1970s and shaped languages such as Pascal, designed by Niklaus Wirth in the late 1960s and widely taught in universities.
Structured design and the waterfall
Structured programming addressed code in the small. Structured design, articulated most influentially by Larry Constantine and Ed Yourdon in the 1970s, addressed the shape of whole programs: decompose a system into modules that are loosely coupled (few dependencies between them) and highly cohesive (each doing one well-defined job). The guiding idea was that good modular structure made systems easier to understand, test, and change. Around the same time, the "waterfall" model gave development a sequence of phases—requirements, design, implementation, testing, maintenance—each completed before the next began3. The model is often traced to a 1970 paper by Winston Royce, though Royce himself warned that a purely linear process was risky and advocated iterating back between phases. The simplified waterfall nonetheless became the standard mental picture of disciplined development, and it dominated large projects and government procurement for decades.
Formal methods and the limits of proof
A more ambitious strand sought mathematical certainty. Formal methods use mathematical notation to specify what a system must do and to prove that an implementation satisfies the specification4. Hoare's 1969 paper on an axiomatic basis for computer programming introduced "Hoare logic," a system of rules for reasoning about what a program does to its variables. In the 1970s and 1980s, specification languages such as Z and VDM, and later the B method, were developed and applied to safety-critical systems—notably railway signaling, where the Paris Métro line 14, opened in 1998, was driven by software developed with the B method. Formal methods proved powerful but expensive and demanding of specialist skill, so they remained confined to domains where failure was catastrophic. Their lasting contribution was to make precision about requirements a recognized engineering value, and to seed ideas—invariants, contracts, model checking—that later tools absorbed.
Testing, verification, and the economics of defects
Because proof was rarely practical, testing became the main way to gain confidence in software. Early testing was often an afterthought, done by the programmers themselves. Through the 1970s and 1980s, testing matured into a discipline with its own techniques: black-box testing (deriving test cases from the specification without looking at the code), white-box or structural testing (exercising the code's internal paths), and systematic methods such as equivalence partitioning and boundary-value analysis. Glenford Myers's 1979 book The Art of Software Testing framed a durable principle: the purpose of testing is to find defects, not to demonstrate correctness. A parallel line of work studied where defects come from. The landmark 1975 study by IBM researchers on the OS/360 project found that a small fraction of modules contained most of the errors—an observation that motivated later work on code review, static analysis, and defect prediction. The economic argument that defects cost far more to fix the later they are found became a standard justification for early review and incremental testing.
Object orientation
By the 1980s, procedural decomposition was straining under systems whose behavior was dominated by many kinds of data that changed over time. Object-oriented development reorganized programs around objects—bundles of data and the operations on that data—rather than around functions. The idea had roots in the 1960s simulation language Simula, developed in Norway by Ole-Johan Dahl and Kristen Nygaard, which introduced classes and inheritance. It matured in Smalltalk, developed at Xerox PARC in the 1970s, and reached wide industrial use with C++ (Bjarne Stroustrup, early 1980s). The 1990s brought a profusion of methods—Grady Booch's, James Rumbaugh's object modeling technique, Ivar Jacobson's use-case approach—which were unified in the mid-1990s as the Unified Modeling Language (UML), a standard notation for describing object designs. Object orientation promised that software could mirror the concepts of its problem domain, making systems easier to extend; it became the dominant paradigm of enterprise software by the late 1990s.
Process maturity and the spiral
As projects kept failing, attention turned to the management of the development process itself. The Capability Maturity Model (CMM), developed at the Software Engineering Institute at Carnegie Mellon University from the late 1980s, rated an organization's processes on five levels, from "initial" (ad hoc) to "optimizing" (continuously improved), on the theory that predictable processes produce predictable products. It was widely adopted, especially in defense contracting, and gave organizations a vocabulary for process improvement, though critics noted that a high maturity rating did not guarantee good software. Meanwhile Barry Boehm's spiral model (1988) offered an alternative to the waterfall: development proceeds in repeated loops, each beginning with risk analysis and ending with a prototype or increment that stakeholders evaluate. The spiral model made explicit what waterfall hid—that requirements are uncertain and risk must be managed iteratively—and it anticipated the incremental, feedback-driven approaches that followed.
Components and models
Two further attempts to raise the level of reuse appeared in the 1990s and 2000s. Component-based development proposed assembling systems from independently developed, replaceable software components with well-defined interfaces, in the spirit of hardware parts. It produced standards such as Microsoft's COM and the CORBA and Enterprise JavaBeans platforms, and it shaped later service-oriented and microservice architectures, though truly plug-and-play reuse proved harder than hoped. Model-driven engineering pushed abstraction further: rather than writing code, developers would build precise models of a system and generate code from them automatically. The Object Management Group's Model Driven Architecture (early 2000s) was its most visible expression5. The approach delivered real benefits in narrow domains—code generation for embedded and telecommunications systems—but general-purpose model-driven development struggled with the gap between models and the messy realities of running systems.
Agile and continuous delivery
The 1990s also produced a reaction against heavy process. "Lightweight" methods—Extreme Programming (Kent Beck, late 1990s), Scrum, and Dynamic Systems Development Method—emphasized short iterations, close collaboration with customers, working software over documentation, and the ability to respond to change. In 2001 seventeen practitioners met at a ski resort in Snowbird, Utah, and published the Manifesto for Agile Software Development, which set these values against the plan-driven orthodoxy6. Agile spread rapidly, first in small teams and startups, then across large organizations, and reshaped how requirements, planning, and testing were done—test-driven development, in which tests are written before the code, became a signature practice.
Agile's emphasis on frequent, small releases fed directly into continuous delivery and DevOps. Continuous integration—automatically building and testing every change—and continuous delivery—keeping software always in a releasable state through automated pipelines—turned the ideal of frequent release into an engineering practice, described influentially in the 2010 book Continuous Delivery by Jez Humble and David Farley. DevOps extended this by dissolving the wall between development and operations, so that the people who build software also run it, supported by automation for deployment, monitoring, and infrastructure7. These movements are treated in depth in the neighboring DevOps and site reliability engineering subfield; within software engineering they mark the point where process, tooling, and organizational structure became inseparable8.
The present
Today's software engineering draws on all of these strands at once. Agile iteration and continuous delivery are the default rhythm of much professional work; automated testing and static analysis carry forward the testing tradition; version control, code review, and continuous integration embody the modular, review-heavy discipline that structured design began. Formal methods survive where correctness is paramount, and lightweight formal tools—type systems, contracts, property-based testing—have quietly spread into ordinary practice. Open-source development and large-scale collaboration platforms changed how teams are organized, and machine learning is now being applied to code completion, defect prediction, and test generation. The open questions are recognizably the old ones in new dress: how to keep large systems understandable as they evolve, how much process is enough, how to verify systems whose behavior emerges from many interacting parts, and how to build software whose correctness and security can be trusted at the scale on which society now depends on it.
References
- Software engineering (History), Wikipedia
- Software crisis, Wikipedia
- Waterfall model, Wikipedia
- Formal methods, Wikipedia
- Model-driven architecture, Wikipedia
- Agile software development (introduction, History), Wikipedia
- DevOps, Wikipedia
- Site reliability engineering, Wikipedia
The frameworks of Software Engineering
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1968-1985
Structured Programming
How should control flow in a program be organized?
- 1969-Present
- 1970-Present
- 1970-1990
- 1970-1995
- 1975-Present
- 1980-Present
Object-oriented programming
How should software be structured around data and behavior?
- 1987-2010
Capability Maturity Model
How can an organization's process be made predictable?
- 1988-2005
Spiral Model
How can risk be managed across repeated development cycles?
- 1995-2015
Component-based software engineering
How can software be assembled from reusable parts?
- 1999-Present
Agile Software Development
How can teams deliver software in short feedback loops?
- 2001-2015
Model-Driven Engineering
Can code be generated automatically from models?
- 2009-Present
DevOps and Continuous Delivery
How can development and operations work as one?
- 2010-Present
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.
Spiral Model reacted against Waterfall Model
Boehm's spiral model was explicitly offered as an alternative to the linear waterfall, replacing its single pass through phases with repeated risk-driven loops and stakeholder evaluation of increments.
Carried by Barry Boehm.
Agile Software Development reacted against Waterfall Model
Agile development defined itself against the heavy, phase-gated plan-driven process that the waterfall model had come to stand for, and the Agile Manifesto's authors framed their values as a rejection of that discipline.
Carried by Agile Manifesto (2001).
Formal Methods influenced by Structured Programming
Structured programming's insistence that programs be built from control structures with single entry and exit made them amenable to formal reasoning. Hoare's 1969 axiomatic basis gave rules for exactly those constructs, and Dijkstra's own work on weakest preconditions grew out of the structured-programming programme.
Carried by C. A. R. Hoare; Edsger W. Dijkstra.
Structured Design grew out of Structured Programming
Structured design extended the top-down decomposition of structured programming from statements to modules. Constantine and Yourdon's coupling-and-cohesion criteria were presented as the design-level counterpart to structured code.
Carried by Larry Constantine; Ed Yourdon.
Software Testing and Verification influenced by Formal Methods
Formal specification gave testing a source of test cases and an oracle: black-box testing derives cases from the specification, and verification ideas such as invariants and contracts fed into testing and static analysis tools.
Model-Driven Engineering influenced by Formal Methods
Model-driven engineering carried forward the formal-methods commitment to precise, checkable models, and model checking and specification languages seeded the modelling notations and generators used in MDA.
Object-oriented programming reacted against Structured Design
Object-oriented design methods defined themselves against the function-and-module decomposition of structured design, replacing it with objects, classes and inheritance as the primary structuring unit.
Carried by Grady Booch.
Component-based software engineering influenced by Object-oriented programming
Component platforms such as CORBA, COM and Enterprise JavaBeans were built on object-oriented interfaces and class-based type systems, so component-based development inherited its interface notion from object orientation.
Model-Driven Engineering influenced by Object-oriented programming
The Unified Modeling Language, consolidated from object-oriented design methods in the mid-1990s, supplied the notation that model-driven architecture and model-driven engineering built on.
Carried by Unified Modeling Language (1997).
Agile Software Development reacted against Capability Maturity Model
Agile methods arose partly as a reaction against process-maturity regimes, whose five-level ratings and heavy documentation were seen as bureaucratic overhead rather than a route to working software.
Agile Software Development influenced by Spiral Model
The spiral model's iterative, risk-driven loops and incremental delivery anticipated the feedback-driven, short-iteration approaches of agile methods, which took up iteration and stakeholder evaluation as core practices.
Carried by Barry Boehm.
DevOps and Continuous Delivery influenced by Agile Software Development
DevOps extended agile's short feedback loops from development into operations, carrying the practice of frequent small increments and cross-functional collaboration into deployment and infrastructure.
Continuous Delivery influenced by Agile Software Development
Continuous delivery built on agile's principle of keeping software in a releasable state through short iterations, automating the build-test-release pipeline that agile teams had practised manually.
Software Testing and Verification influenced by Structured Programming
Structured programming's single-entry single-exit control flow made path-based white-box testing tractable, and structural testing techniques were defined over the same control structures.
Object-oriented programming reacted against Structured Programming
Object orientation reorganized programs around data-bearing objects rather than the function decomposition of structured design, and its advocates presented it as a response to procedural decomposition straining on large systems.
Component-based software engineering influenced by Structured Design
Component-based development inherited structured design's goal of loose coupling and high cohesion, now applied to independently developed replaceable parts with well-defined interfaces.
Capability Maturity Model influenced by Waterfall Model
The Capability Maturity Model codified the phase-based, plan-driven discipline of the waterfall tradition into organizational process levels, and was adopted above all in the defense contracting world where waterfall dominated.
Carried by Software Engineering Institute.
Software Testing and Verification rival of Software Testing
The two testing strands ran in parallel through the 1970s and 1980s, one maturing technique and defect economics, the other verification-oriented, competing to answer how confidence in software is to be gained.
Beyond the field
Where Software Engineering's ideas came from in other fields, and what they led to there: the strongest 12 of 101 links.
Structured Programming led to Structured Design in Software Architecture
Structured Design grew directly out of structured programming: Yourdon and Constantine's 1974 book applied the principle of hierarchical, single-entry single-exit decomposition from programs to the design of module structures.
Carried by Edward Yourdon; Larry Constantine; Structured Design (1975).
Formal Methods led to Lightweight Formal Methods in Formal Methods
Lightweight formal methods were proposed in the mid-1990s as a deliberate branch of formal methods, applying them selectively where cost-effective rather than for full verification.
Structured Design influenced by Structured Programming in Language Design
Structured Design applied structured programming's top-down, single-entry single-exit decomposition to the design of module hierarchies, transforming program structure principles into design heuristics.
Carried by Edward Yourdon; Larry Constantine.
Waterfall Model grew out of Systems Development Life Cycle in Systems Analysis And Design
The waterfall model for software descended from the systems development life cycle used in business systems analysis, adopting its phases of requirements, analysis, design, implementation and maintenance in strict sequence.
Carried by Winston W. Royce.
Waterfall Model grew out of Systems development life cycle in Software Process Models
The waterfall model is the sequential, document-driven form of the systems development life cycle; Royce's 1970 paper and later expositions presented the waterfall as the basic SDLC process for software.
Carried by Winston W. Royce; Managing the Development of Large Software Systems (1970).
Waterfall Model provoked Agile Software Development in Project Management
Agile software development defined itself against the waterfall model's sequential, plan-driven lifecycle, presenting iterative and adaptive development as its replacement. The Agile Manifesto's authors explicitly framed their values as a reaction to heavyweight, waterfall-style processes.
Carried by Agile Manifesto (2001).
Object-oriented programming influenced Complex-value and object-oriented data models in Database Theory
Object-oriented data models took object identity, encapsulation, classes and inheritance directly from object-oriented programming languages and applied them to persistent data.
Object-oriented programming influenced Object-oriented and object-relational databases in Databases
Object-oriented databases took the concepts of class, inheritance, encapsulation and object identity directly from object-oriented programming and applied them to persistent data. The database models were built by importing these programming-language constructs.
Object-oriented programming influenced Object-Oriented Analysis in Requirements 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 programming influenced Object-Oriented Analysis and Design in Systems Analysis And Design
Object-oriented analysis and design methods were built to carry the object model of OO programming languages into the analysis and design phases. The encapsulation, inheritance and message-passing concepts of Smalltalk and C++ were taken up by Booch, Rumbaugh and Jacobson as the vocabulary of their design methods.
Carried by Grady Booch; James Rumbaugh; Ivar Jacobson.
Object-oriented programming influenced Object-oriented data modeling in Data Modeling
Object-oriented data modeling took its core concepts (objects, classes, encapsulation, inheritance, identity) directly from object-oriented programming languages such as Smalltalk and C++. The ODMG standard and early OODBMS work applied these programming constructs to persistent data storage.
Carried by Smalltalk; C++; ODMG.
Spiral Model reacted against Waterfall Model in Software Process Models
Boehm presented the spiral model explicitly as a risk-driven alternative to the waterfall model, which he criticised for treating development as a single sequential pass. The spiral's iterative cycles were defined against waterfall's linear phases.
Carried by Barry Boehm; A Spiral Model of Software Development and Enhancement (1986).

Software Engineering is a planet in Nousfarer
Its city has a tower for each of these 14 frameworks. Land, walk in, and climb one concept at a time.
Land on Software EngineeringRelated fields
Fields its ideas are linked to
- Software Process Models 12 links
- Software Testing 10 links
- Software Architecture 8 links
- Programming Paradigms 7 links
- Software Evolution 7 links
- Systems Verification 7 links
- Project Management 4 links
- Model Based Systems Engineering 4 links
- Systems Analysis And Design 3 links
- Devops And Sre 3 links
- Formal Methods 3 links
- Requirements Engineering 3 links
More in Software Engineering
- Computing Education
- Design Patterns
- Devops And Sre
- Formal Methods
- Open Source Software
- Requirements Engineering
- Software Architecture
- Software Evolution
- Software Process Models
- Software Testing
See where Software Engineering sits on the Map of Human Knowledge