Design Patterns

Design patterns are named, reusable solutions to problems that recur in software design.

8 frameworks, from 1987 to today · Software Engineering · Computer Science

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

Overview

Design patterns are named, reusable solutions to problems that recur in software design1. A pattern is not a finished piece of code but a template for a way of arranging objects, modules, or components that has worked before and can be adapted to a new situation1. The idea matters because software design is hard to talk about: two experienced developers may recognize the same structural problem and reach for the same kind of solution, yet have no shared vocabulary for it. Patterns give that vocabulary. They also give teams a way to pass on design judgment without passing on code, and they give newcomers a shortcut into the accumulated experience of the field. The history of design patterns is the story of how that idea moved from architecture into software, how it was codified, how it was criticized, and how it was partly absorbed into the languages and frameworks that programmers now use every day.

Christopher Alexander and the Pattern Language Idea

The intellectual root of software design patterns lies outside software, in the work of the architect Christopher Alexander123. In A Pattern Language (1977), written with Sara Ishikawa and Murray Silverstein, Alexander argued that good buildings and towns could be described through a large set of recurring "patterns"—each a short statement of a problem in the built environment together with a proven arrangement that resolves it45. A pattern such as "light on two sides of every room" names a problem (rooms with windows on only one side feel gloomy and poorly oriented) and a solution (place rooms so that they receive daylight from at least two directions). Alexander's patterns were meant to be combined: each pattern pointed to smaller patterns that completed it and larger patterns that contained it, forming a network he called a pattern language5.

Alexander's claim was that ordinary people, not only architects, could use such a language to shape their own surroundings54. The patterns were written in a consistent form—context, problem, forces, solution—and were grounded in observation of what made buildings feel alive5. This structure, and the ambition to capture design knowledge in reusable named units, is what software developers later borrowed. Alexander himself was not writing about software, and the transfer was an analogy, but it proved unusually productive.

From Architecture to Object-Oriented Software

Through the late 1980s and early 1990s, programmers working in object-oriented languages began to notice that certain arrangements of classes and objects kept reappearing. The object-oriented style, which organizes a program around objects that bundle data with the operations on that data, made design decisions visible in a new way: the choice of which objects exist, which one holds responsibility for what, and how they communicate could make a program easy or hard to change. Yet the vocabulary for discussing these choices was thin.

Several people pushed the analogy with Alexander. Kent Beck and Ward Cunningham, working with Smalltalk, presented a set of patterns for user-interface design at the OOPSLA conference in 1987, explicitly invoking Alexander's format. Erich Gamma, then working on his doctoral research, began cataloguing patterns he saw in software frameworks. The idea spread through conference workshops and informal networks rather than through a single founding text.

The Gang of Four and the Codification of Object-Oriented Patterns

The turning point came in 1994 with Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides—soon known as the "Gang of Four."61 The book catalogued 23 patterns, each described in a fixed template: name, intent, motivation, structure, participants, consequences, and sample code. The patterns were grouped into three families. Creational patterns, such as Factory Method and Singleton, dealt with how objects are made6. Structural patterns, such as Adapter and Composite, dealt with how objects are composed into larger structures6. Behavioral patterns, such as Observer and Strategy, dealt with how objects divide responsibilities and communicate6.

The book's influence came from more than its catalogue. It gave the field a shared format and a shared set of names. A developer could say "use an Observer here" and be understood: the Observer pattern defines a one-to-many dependency in which when one object changes state, all its dependents are notified automatically—the mechanism behind much event handling in graphical interfaces. The Gang of Four framed patterns as descriptions of proven practice rather than inventions, and they emphasized that patterns should be adapted, not copied. The book became one of the most cited works in software engineering and shaped how a generation was taught object-oriented design.

The Pattern Languages of Programs Tradition

Alongside the Gang of Four's catalogue, a second strand treated patterns as a living, communal practice rather than a fixed reference. The Pattern Languages of Programs (PLoP) conferences, beginning in the mid-1990s, created a forum where practitioners wrote and workshopped patterns in Alexander's spirit178. The PLoP tradition emphasized "pattern mining"—finding patterns in existing systems—and a review process in which authors presented drafts to a group that offered feedback in a structured, supportive format. This tradition produced patterns for concurrency, distributed systems, organizational design, and pedagogy, and it kept the idea of a pattern language as an interconnected whole alive, in contrast to the Gang of Four's more catalogue-like presentation.

Architectural Patterns and Styles

At a larger scale, the same impulse produced architectural patterns and styles: named, high-level arrangements for the overall shape of a system9. Where object-oriented patterns concern the relationships among classes, architectural patterns concern the organization of major subsystems and their interactions9. Well-known examples include the layered architecture, in which a system is organized into layers each depending only on the one below; the model-view-controller arrangement, which separates data, presentation, and input handling; and the pipe-and-filter style, in which data flows through a sequence of processing stages. These ideas overlapped with the emerging discipline of software architecture, which concerned itself with the large-scale structure of systems and the qualities—performance, modifiability, security—that such structures promote or inhibit9. Architectural patterns gave architects a vocabulary comparable to what the Gang of Four gave designers.

Enterprise Application Architecture Patterns

A parallel catalogue emerged for the particular problems of business software. Martin Fowler's Patterns of Enterprise Application Architecture (2002) collected patterns for the recurring structures of enterprise systems: how to map objects to relational databases (the Data Mapper and Active Record patterns), how to organize business logic (the Domain Model and Transaction Script patterns), and how to coordinate layers and handle web requests. These patterns addressed problems that the Gang of Four's object-oriented catalogue did not reach—persistence, transactions, and the layering of large business systems—and they became standard reference material for developers building such systems.

The Critique: Patterns as a Sign of Language Deficiency

Not everyone accepted the pattern idea uncritically. A prominent line of criticism, associated with Peter Norvig and later with the "pattern-as-language-deficiency" argument, held that many design patterns are workarounds for missing features in a programming language6. If a language had first-class functions, the argument went, the Strategy pattern would be unnecessary; if it had proper modules or macros, other patterns would dissolve. On this view, the prominence of patterns in a language is a measure of what that language lacks, and the healthiest outcome is for patterns to disappear as languages improve. This critique did not destroy the pattern movement, but it reframed patterns as provisional knowledge—useful now, perhaps obsolete later—rather than permanent design wisdom.

Idioms and the Absorption of Patterns into Languages and Frameworks

The critique proved partly prophetic. Over the 2000s and 2010s, many patterns were absorbed into languages, libraries, and frameworks, so that programmers used them without naming them. The Iterator pattern became a built-in feature of many languages' collection libraries. The Observer pattern was built into event systems and reactive frameworks. Dependency injection, a pattern for supplying an object's collaborators from outside rather than having it create them, became a standard feature of enterprise frameworks. At the same time, the notion of an "idiom"—a pattern specific to one language or platform—gained currency, recognizing that what counts as a reusable solution depends on the tools at hand10. Patterns did not vanish; they migrated from explicit catalogue entries into the infrastructure of everyday programming, and the vocabulary of patterns remained in use for communicating design intent even when the code no longer needed a named workaround.

The Present: Patterns as Vocabulary and as Moving Target

Today design patterns are taught in most software engineering curricula and remain a standard part of a developer's vocabulary. The Gang of Four catalogue is still cited, though its patterns are increasingly discussed as historical reference points rather than as things to implement by hand. The PLoP tradition continues in pattern-writing communities, and architectural patterns remain central to software architecture practice. The open questions are the ones the critique raised: which patterns are genuine design knowledge and which are artifacts of current languages, and how patterns should evolve as languages and frameworks absorb them. The field's history suggests that patterns are best understood not as a fixed library but as a way of capturing and transmitting design experience—one that changes as the tools of software development change.

References

  1. Software design pattern (introduction, History), Wikipedia
  2. Design pattern, Wikipedia
  3. Christopher Alexander, Wikipedia
  4. A Pattern Language, Wikipedia
  5. Pattern language (Origin, introduction), Wikipedia
  6. Design Patterns (introduction, Creational, Structural, Behavioral, Reception), Wikipedia
  7. Pattern Languages of Programs, Wikipedia
  8. The Hillside Group, Wikipedia
  9. List of software architecture styles and patterns, Wikipedia
  10. Programming idiom, Wikipedia

The frameworks of Design Patterns

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

  1. 1987-Present

    Pattern Language

    How can recurring design problems be named and solved together?

    Fly to its tower in Nousfarer

  2. 1994-2010

    Gang of Four Object-Oriented Design Patterns

    Which recurring arrangements of objects solve common design problems?

    Fly to its tower in Nousfarer

  3. 1994-Present

    List of software architecture styles and patterns

    What named large-scale structures organize a whole system?

    Fly to its tower in Nousfarer

  4. 1994-Present

    Pattern Languages of Programs

    How do practitioners mine and workshop patterns as a community?

    Fly to its tower in Nousfarer

  5. 1996-Present

    Pattern-as-Language-Deficiency Critique

    Are design patterns just patches for weak languages?

    Fly to its tower in Nousfarer

  6. 1996-Present

    Programming idiom

    What solutions are specific to one language or platform?

    Fly to its tower in Nousfarer

  7. 2002-Present

    Enterprise Application Architecture Patterns

    What structures recur in large business software systems?

    Fly to its tower in Nousfarer

  8. 2004-Present

    Idioms and Framework-Absorbed Patterns

    How are named solutions absorbed into everyday frameworks and idioms?

    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.

Pattern LanguageGang of Four Object-Oriented Design P…List of software architecture styles …Pattern Languages of ProgramsPattern-as-Language-Deficiency Critiq…Programming idiomEnterprise Application Architecture P…Idioms and Framework-Absorbed Patterns

Beyond the field

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

Design Patterns is a planet in Nousfarer

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

Land on Design Patterns

Related fields

Fields its ideas are linked to

More in Software Engineering

See where Design Patterns sits on the Map of Human Knowledge