- Atlas
- Computer Science
- Software Architecture
Software Architecture
Software architecture is the discipline of deciding the large-scale shape of a software system before and while it is built: which parts exist, what each is responsible for, how they talk to one another, and which qualities—speed, security, the ability to change—the whole arrangement will favor.
14 frameworks, from 1968 to today · Software Engineering · Computer Science
- Structured Design 1968-1985
- Structured Analysis 1975-1990
- Architectural Styles 1992-Present
- Architecture description language 1992-2005
- Architectural Patterns 1994-Present
- Multiple-View Architecture Description 1995-Present
- Architecture Tradeoff Analysis Method 1998-2015
- Quality-Attribute Architecture 1998-Present
- Emergent Architecture 2001-Present
- Service-Oriented Architecture 2001-2012
- Domain-Driven Design 2003-Present
- Cloud-Native Architecture 2014-Present
- Microservices 2014-Present
- Continuous design 2017-Present
Overview
Software architecture is the discipline of deciding the large-scale shape of a software system before and while it is built: which parts exist, what each is responsible for, how they talk to one another, and which qualities—speed, security, the ability to change—the whole arrangement will favor1. The stakes are easy to state and hard to meet. A program of a few hundred lines can be held in one person's head; a system of millions of lines, built over years by people who come and go, cannot. Architecture is the field's answer to that problem: it makes the big decisions explicit, so that teams can work in parallel, newcomers can find their way, and the system can survive the changes that will inevitably come. Its history is a sequence of attempts to name the right units of decomposition, to describe them, and to reason about the qualities they produce.
Structured Design and the First Decomposition Methods (1960s–1970s)
In the early decades of computing, "design" meant whatever the programmer did before typing. As programs grew into systems, a body of method grew up around the question of how to break a program into pieces. The most influential answer came from Larry Constantine, who in the late 1960s and early 1970s developed structured design around the idea of coupling and cohesion: modules should be as independent of one another as possible (low coupling) and each should do one closely related job (high cohesion)23. Constantine's collaboration with Ed Yourdon produced the book Structured Design (1975), which taught a generation to draw structure charts and to judge a decomposition by these two measures.
The companion movement, structured analysis, asked how to derive that structure from requirements2. Tom DeMarco's Structured Analysis and System Specification (1978) and Yourdon's and Constantine's work popularized data-flow diagrams—pictures of processes, data stores, and the flows between them—as a way to model what a system must do before deciding how it would be built. Related methods proliferated: Jackson Structured Programming, based on the shape of input and output data, and later the real-time extensions of Ward and Mellor and of Hatley and Pirbhai. These methods shared a belief that a good decomposition could be derived systematically, and that the resulting diagrams were the proper object of design review.
Architecture as a Named Concern (late 1980s–1990s)
By the late 1980s, practitioners noticed that some decisions sat above the level of modules and data flows: the choice of layers, of clients and servers, of how components would be distributed across machines. The word architecture began to be used for this level. A landmark was the 1992 paper "Foundations for the Study of Software Architecture" by Dewayne Perry and Alexander Wolf, which proposed that architecture be described in terms of elements, form (how elements are arranged), and rationale (why). The 1990s then produced a wave of work on how to write architecture down.
Architecture description languages (ADLs) were formal notations for specifying a system's components, connectors, and configurations4. Examples include Darwin, developed at Imperial College London in the early 1990s for distributed systems; Wright, from Carnegie Mellon, which let architects specify connector behavior; and Acme, also from Carnegie Mellon, intended as a common interchange language across ADLs. The hope was that architecture could be analyzed mechanically—checking consistency, simulating behavior, or reasoning about properties—much as a compiler checks code.
In parallel, the 4+1 view model of Philippe Kruchten (1995) argued that no single diagram could capture an architecture. It proposed describing a system through several views—logical, process, development, physical, and scenarios—each serving a different audience5. This multiple-view idea became standard: an architecture is a set of coordinated descriptions, not one picture.
Styles and Patterns (1990s)
The other major strand of the 1990s was the cataloguing of recurring arrangements. An architectural style names a family of systems sharing a structure and a set of constraints: layered systems, in which each layer uses only the one below; pipe-and-filter systems, in which independent processing stages pass data along; blackboard systems, in which independent specialists cooperate through a shared data store; and the client–server and event-based styles. Mary Shaw and David Garlan's Software Architecture: Perspectives on an Emerging Discipline (1996) gave the field its textbook synthesis, treating styles as the vocabulary of architectural design.
The patterns movement, drawing on Christopher Alexander's architectural pattern language and on the Gang of Four's object-oriented design patterns (1994), extended this to named solutions for recurring problems67. The architectural patterns that followed—Model-View-Controller, the Broker, the Layers pattern, and later the enterprise patterns of Martin Fowler's Patterns of Enterprise Application Architecture (2002)—gave architects a shared language of trade-offs. The Pattern Languages of Programs (PLoP) conferences, beginning in 1994, became the venue where these were workshopped and refined6.
Quality Attributes and Evaluation (late 1990s–2000s)
A persistent complaint was that architecture discussions were aesthetic. The quality-attribute turn made them testable. The Software Engineering Institute at Carnegie Mellon, building on work by Len Bass, Rick Kazman, and Paul Clements, argued that architecture exists to deliver quality attributes—performance, availability, security, modifiability, usability—and that these can be made concrete as scenarios. Their book Software Architecture in Practice (first edition 1998) organized the field around this idea.
The Architecture Tradeoff Analysis Method (ATAM), developed at the SEI in the late 1990s, turned this into a structured evaluation: stakeholders generate quality scenarios, architects explain how the design responds, and the group identifies risks, sensitivity points, and trade-off points—places where improving one quality degrades another. ATAM's contribution was procedural: it made architectural review a repeatable, evidence-based exercise rather than a matter of taste.
Service Orientation and the Distributed Turn (2000s)
As systems spread across networks and organizations, the unit of decomposition shifted from the module to the service—a remotely accessible capability with a defined contract. Service-oriented architecture (SOA) emerged in the early 2000s, promoted by vendors and standards bodies around web services (SOAP, WSDL, UDDI) and later REST. Its promise was loose coupling across organizational boundaries: services could be reused, composed into business processes, and replaced independently. Its difficulties—governance, the cost of remote calls, and the gap between the promise of reuse and the reality of integration—became a cautionary tale that shaped what came next.
Agile, Emergent Architecture, and Domain-Driven Design (2000s)
The Agile movement's rise posed a direct challenge: if architecture is decided up front, how does that square with iterative delivery and embracing change? The answer that took hold was emergent architecture—the idea that structure should grow from working code and refactoring rather than be fixed in advance. This was contested; many argued that some decisions are too costly to defer. The practical resolution was a middle path: enough up-front structure to guide the work, refined continuously.
A complementary answer came from domain-driven design, introduced by Eric Evans in his 2003 book8. DDD argued that the primary unit of decomposition should be the bounded context—an explicit boundary within which a particular model of the domain applies—and that architects should invest in a shared ubiquitous language between developers and domain experts. Its tactical patterns (entities, value objects, aggregates, repositories) and strategic patterns (context mapping) gave teams a way to align software structure with business structure.
Microservices and Cloud-Native Architecture (2010s)
The 2010s brought the most visible architectural shift in the field's history. Microservices—an approach in which a system is composed of small, independently deployable services, each owning its own data—were popularized by practitioners at companies such as Amazon and Netflix and named in a widely read 2014 article by James Lewis and Martin Fowler. The approach promised independent deployment, technology heterogeneity, and organizational scaling, at the cost of distributed-systems complexity: network failures, data consistency, and operational overhead.
Cloud-native architecture extended this: systems designed for elastic, on-demand infrastructure, packaged in containers, orchestrated by platforms such as Kubernetes (released by Google in 2014), and instrumented for observability. The architectural vocabulary shifted toward resilience patterns—circuit breakers, bulkheads, retries with backoff—and toward treating infrastructure as code. The trade-offs were real, and the field's literature increasingly warned against distributed monoliths and premature decomposition.
Evolutionary Architecture and Fitness Functions (2010s–present)
The most recent strand makes change itself the design goal. Evolutionary architecture, articulated by Neal Ford, Rebecca Parsons, and Patrick Kua in their 2017 book, treats architecture as something that should support guided, incremental change over time. Its central tool is the fitness function: an automated check—a test, a metric, a monitoring rule—that verifies an architectural characteristic is being preserved. A fitness function might assert that no module in one layer imports from another, or that response time stays under a threshold. The idea connects architecture back to continuous delivery and automated testing, making architectural intent something a build pipeline can enforce.
The Present
Today's practice draws on all of these layers. Teams routinely describe systems through multiple views, choose among catalogued styles and patterns, and evaluate designs against quality scenarios. Domain-driven design supplies the vocabulary for boundaries; microservices and cloud-native platforms supply the deployment model; fitness functions and automated checks supply the guardrails. The open questions are the old ones in new dress: how much structure to decide up front, how to keep architecture aligned with organizations as they grow, how to manage the operational and cognitive cost of distribution, and how to make architectural knowledge survive the departure of the people who hold it. The field's history is, in the end, a long argument about where to draw the lines—and how to keep them meaningful as everything around them changes.
References
- Software architecture (introduction, Scope), Wikipedia
- Structured analysis (Structured design, History, introduction), Wikipedia
- Coupling (computer programming) (History), Wikipedia
- Architecture description language, Wikipedia
- 4+1 architectural view model, Wikipedia
- Software design pattern (History), Wikipedia
- Design Patterns, Wikipedia
- Domain-driven design, Wikipedia
The frameworks of Software Architecture
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1968-1985
- 1975-1990
- 1992-Present
Architectural Styles
What recurring large-scale arrangements do systems share?
- 1992-2005
Architecture description language
How can architecture be written down precisely?
- 1994-Present
Architectural Patterns
What named solutions fit recurring design problems?
- 1995-Present
Multiple-View Architecture Description
How can one system be described from many viewpoints?
- 1998-2015
Architecture Tradeoff Analysis Method
How do we evaluate a design against its qualities?
- 1998-Present
Quality-Attribute Architecture
How does structure deliver speed, security and changeability?
- 2001-Present
- 2001-2012
Service-Oriented Architecture
How should capabilities be exposed across a network?
- 2003-Present
Domain-Driven Design
How should software structure follow the business domain?
- 2014-Present
Cloud-Native Architecture
How should systems be built for elastic infrastructure?
- 2014-Present
- 2017-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.
Structured Analysis grew out of Structured Design
Structured analysis grew directly out of structured design's decomposition agenda: Yourdon and Constantine's coupling and cohesion criteria were paired with data-flow modeling so that structure charts could be derived from requirements. DeMarco's 1978 book formalized the data-flow side of the same method family.
Carried by Ed Yourdon; Tom DeMarco; Structured Analysis and System Specification (1978).
Architectural Styles influenced by Structured Design
Architectural styles generalized structured design's vocabulary of module arrangements (layers, pipes, clients) into named families with constraints, drawing on the same decomposition concerns. Shaw and Garlan's 1996 synthesis explicitly built on the earlier module-structure tradition.
Carried by Mary Shaw; David Garlan; Software Architecture: Perspectives on an Emerging Discipline (1996).
Multiple-View Architecture Description influenced by Architecture description language
Multiple-view description responded to the limits of single-notation ADLs by arguing that an architecture needs several coordinated views; Kruchten's 4+1 model (1995) was framed against the one-diagram assumption of ADL work. The view idea carried the ADL concern for precise description into a multi-perspective form.
Carried by Philippe Kruchten.
Emergent Architecture reacted against Quality-Attribute Architecture
Emergent architecture defined itself against up-front quality-attribute-driven design, arguing that structure should grow from working code and refactoring rather than be fixed in advance to meet predicted quality scenarios. The agile critique targeted exactly the plan-then-build stance of the quality-attribute school.
Continuous design grew out of Emergent Architecture
Continuous design is the later, tooling-supported form of emergent architecture: structure is refined continuously through deployment and refactoring rather than fixed up front. It carries the emergent premise into cloud-native practice.
Microservices reacted against Service-Oriented Architecture
Microservices were framed as a corrective to SOA's heavy governance, enterprise service bus and standards-driven integration, keeping the service unit but rejecting the centralized infrastructure. Lewis and Fowler's 2014 article positioned microservices against the SOA cautionary tale.
Carried by James Lewis; Martin Fowler.
Microservices influenced by Domain-Driven Design
Microservices adopted domain-driven design's bounded context as the criterion for service boundaries, so that each service owns one model and its data. The 2014 microservices literature explicitly invokes bounded contexts to justify decomposition.
Carried by Martin Fowler; Eric Evans.
Continuous design influenced by Microservices
Continuous design grew out of microservice and cloud-native practice, where independently deployable services make architecture a matter of ongoing evolution rather than a fixed blueprint. The continuous-delivery infrastructure of microservices carried the idea.
Emergent Architecture reacted against Structured Design
Emergent architecture rejected the structured-design premise that a good decomposition can be derived systematically before construction, insisting instead on continuous refactoring. The rejection is of the whole up-front-method tradition rather than of one technique.
Architectural Styles influenced by Structured Analysis
The data-flow and process-structure vocabulary of structured analysis fed into the cataloguing of styles such as pipe-and-filter and layered systems, which reused its process-and-flow imagery. The connection is real but secondary to the module-level inheritance from structured design.
Carried by Mary Shaw; David Garlan.
Cloud-Native Architecture influenced by Service-Oriented Architecture
Cloud-native architecture inherited SOA's service orientation but recast it around elastic, on-demand infrastructure and containers. The service-as-unit premise passed through, while the enterprise-integration apparatus was dropped.
Beyond the field
Where Software Architecture's ideas came from in other fields, and what they led to there: the strongest 12 of 46 links.
Structured Design grew out of Structured Programming in Software Engineering
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).
Structured Analysis influenced Object-Oriented Analysis in Requirements Engineering
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.
Structured Analysis influenced Structured systems analysis and design method in Requirements Engineering
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.
Multiple-View Architecture Description led to ISO/IEC 42010 in Enterprise Architecture
ISO/IEC 42010's viewpoint and view concepts grew directly out of multiple-view architecture description research, which argued that architectures must be described from several stakeholder perspectives. The standard codified that multi-view approach.
Microservices grew out of Service-oriented architecture in Enterprise Systems
Microservices were articulated by practitioners such as Lewis and Fowler as a refinement of service-oriented architecture, keeping the coarse-grained service boundary while rejecting SOA's heavy enterprise service bus and WS-* governance. The 2014 article 'Microservices' explicitly positions the style against SOA practice.
Carried by James Lewis; Martin Fowler; Microservices (2014).
Continuous design grew out of Continuous Delivery in Software Engineering
Continuous design is a direct extension of continuous delivery: once deployment is automated and frequent, architectural and design decisions can also be made and revised continuously. The later idea applies the delivery pipeline's incremental, feedback-driven logic to design itself.
Carried by Jez Humble; David Farley; Continuous Delivery (2010).
Continuous design grew out of Agile and Continuous Delivery in Software Evolution
Continuous design extends agile and continuous delivery thinking from code and deployment to architectural decisions, arguing that design too should proceed in small, reversible increments. It grew directly out of the continuous delivery movement's practices of frequent, automated release.
Carried by Jez Humble; David Farley; Continuous Delivery (2010).
Structured Design influenced Object-Oriented Analysis in Requirements Engineering
Object-oriented analysis inherited structured design's concern with module structure, coupling and cohesion, and its top-down decomposition discipline, recast around objects. The OO design literature builds on these structured design criteria.
Carried by Larry Constantine.
Structured Design influenced by Structured programming in Programming Languages
Structured programming as taught in programming languages, from Dijkstra's 1968 letter onward, provided the control-structure discipline and stepwise refinement that structured design built its module decomposition on.
Carried by Edsger W. Dijkstra.
Structured Design influenced by Structured Analysis and Design Technique in Model Based Systems Engineering
Structured Design by Stevens, Myers and Constantine (1974) took over SADT's decomposition of a system into hierarchical, loosely coupled modules and its data-flow orientation, adapting them to software module design.
Carried by Structured Design (1974); Larry Constantine.
Structured Design grew out of Structured Programming in Language Design
Structured Design by Stevens, Myers and Constantine built directly on structured programming's principles, extending them from control flow to module decomposition and coupling. It applied the structured-programming discipline to software architecture.
Carried by Larry Constantine; Structured Design (1974).
Structured Design influenced by Structured Programming in Language Design
The structured programming movement in language design, with Dijkstra's 1968 letter and the 1969 NATO conference, gave structured design its top-down, single-entry single-exit control discipline that module decomposition presupposed.
Carried by Edsger W. Dijkstra; NATO Conference on Software Engineering (1969).

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