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

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

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

  1. Software architecture (introduction, Scope), Wikipedia
  2. Structured analysis (Structured design, History, introduction), Wikipedia
  3. Coupling (computer programming) (History), Wikipedia
  4. Architecture description language, Wikipedia
  5. 4+1 architectural view model, Wikipedia
  6. Software design pattern (History), Wikipedia
  7. Design Patterns, Wikipedia
  8. 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.

  1. 1968-1985

    Structured Design

    How should a program be broken into modules?

    Fly to its tower in Nousfarer

  2. 1975-1990
  3. 1992-Present

    Architectural Styles

    What recurring large-scale arrangements do systems share?

    Fly to its tower in Nousfarer

  4. 1992-2005

    Architecture description language

    How can architecture be written down precisely?

    Fly to its tower in Nousfarer

  5. 1994-Present

    Architectural Patterns

    What named solutions fit recurring design problems?

    Fly to its tower in Nousfarer

  6. 1995-Present

    Multiple-View Architecture Description

    How can one system be described from many viewpoints?

    Fly to its tower in Nousfarer

  7. 1998-2015

    Architecture Tradeoff Analysis Method

    How do we evaluate a design against its qualities?

    Fly to its tower in Nousfarer

  8. 1998-Present

    Quality-Attribute Architecture

    How does structure deliver speed, security and changeability?

    Fly to its tower in Nousfarer

  9. 2001-Present

    Emergent Architecture

    Should structure be planned or allowed to emerge?

    Fly to its tower in Nousfarer

  10. 2001-2012

    Service-Oriented Architecture

    How should capabilities be exposed across a network?

    Fly to its tower in Nousfarer

  11. 2003-Present

    Domain-Driven Design

    How should software structure follow the business domain?

    Fly to its tower in Nousfarer

  12. 2014-Present

    Cloud-Native Architecture

    How should systems be built for elastic infrastructure?

    Fly to its tower in Nousfarer

  13. 2014-Present

    Microservices

    How small and independent should deployable parts be?

    Fly to its tower in Nousfarer

  14. 2017-Present

    Continuous design

    How can architecture keep changing after it is built?

    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.

Structured DesignStructured AnalysisArchitectural StylesArchitecture description languageArchitectural PatternsMultiple-View Architecture DescriptionArchitecture Tradeoff Analysis MethodQuality-Attribute ArchitectureEmergent ArchitectureService-Oriented ArchitectureDomain-Driven DesignCloud-Native ArchitectureMicroservicesContinuous design

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.

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 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 Architecture

Related fields

Fields its ideas are linked to

More in Software Engineering

See where Software Architecture sits on the Map of Human Knowledge