- Atlas
- Computer Science
- Design Patterns
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
- Pattern Language 1987-Present
- Gang of Four Object-Oriented Design Patterns 1994-2010
- List of software architecture styles and patterns 1994-Present
- Pattern Languages of Programs 1994-Present
- Pattern-as-Language-Deficiency Critique 1996-Present
- Programming idiom 1996-Present
- Enterprise Application Architecture Patterns 2002-Present
- Idioms and Framework-Absorbed Patterns 2004-Present
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
- Software design pattern (introduction, History), Wikipedia
- Design pattern, Wikipedia
- Christopher Alexander, Wikipedia
- A Pattern Language, Wikipedia
- Pattern language (Origin, introduction), Wikipedia
- Design Patterns (introduction, Creational, Structural, Behavioral, Reception), Wikipedia
- Pattern Languages of Programs, Wikipedia
- The Hillside Group, Wikipedia
- List of software architecture styles and patterns, Wikipedia
- 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.
- 1987-Present
Pattern Language
How can recurring design problems be named and solved together?
- 1994-2010
Gang of Four Object-Oriented Design Patterns
Which recurring arrangements of objects solve common design problems?
- 1994-Present
List of software architecture styles and patterns
What named large-scale structures organize a whole system?
- 1994-Present
Pattern Languages of Programs
How do practitioners mine and workshop patterns as a community?
- 1996-Present
Pattern-as-Language-Deficiency Critique
Are design patterns just patches for weak languages?
- 1996-Present
Programming idiom
What solutions are specific to one language or platform?
- 2002-Present
Enterprise Application Architecture Patterns
What structures recur in large business software systems?
- 2004-Present
Idioms and Framework-Absorbed Patterns
How are named solutions absorbed into everyday frameworks and idioms?
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.
Gang of Four Object-Oriented Design Patterns grew out of Pattern Language
The Gang of Four explicitly took Christopher Alexander's pattern idea and his context-problem-solution template as the model for cataloguing object-oriented designs. Their 1994 book presents itself as applying Alexander's approach to software.
Carried by Christopher Alexander; Design Patterns (1994); Erich Gamma.
Pattern Languages of Programs grew out of Pattern Language
The Pattern Languages of Programs conferences were founded to carry on Alexander's pattern-language spirit inside software, emphasizing interconnected patterns and communal workshopping rather than a fixed catalogue. The tradition grew directly out of the pattern-language idea.
Carried by Pattern Languages of Programs.
Pattern-as-Language-Deficiency Critique reacted against Gang of Four Object-Oriented Design Patterns
The language-deficiency critique arose directly against the Gang of Four's claim that patterns capture permanent design wisdom, arguing that many of their patterns merely patch missing language features. It defined itself by rejecting the catalogue's framing of patterns as lasting knowledge.
Carried by Peter Norvig.
List of software architecture styles and patterns influenced by Pattern Language
The idea of naming recurring structural solutions in a pattern format was carried from Alexander's pattern language into architecture-level software styles and patterns. Architectural pattern writing adopted the named-problem-and-solution format.
Carried by Christopher Alexander.
Enterprise Application Architecture Patterns influenced by Pattern Language
Martin Fowler's enterprise pattern catalogue uses the Alexander-derived format of named problem and proven solution, extending the pattern-language approach to business systems. The cataloguing impulse is inherited from the pattern-language tradition.
Carried by Martin Fowler; Patterns of Enterprise Application Architecture (2002).
Pattern Languages of Programs rival of Gang of Four Object-Oriented Design Patterns
The PLoP tradition and the Gang of Four catalogue were contemporaries offering competing visions of what patterns are: a communal, evolving language versus a fixed reference catalogue. The two strands competed over how pattern knowledge should be produced and presented.
Carried by Pattern Languages of Programs; Design Patterns (1994).
Programming idiom influenced by Gang of Four Object-Oriented Design Patterns
The distinction between general design patterns and language-specific idioms was drawn partly in response to the Gang of Four's language-neutral catalogue, noting that some named solutions only make sense in particular languages. The idiom notion sharpened the catalogue's scope.
Idioms and Framework-Absorbed Patterns grew out of Gang of Four Object-Oriented Design Patterns
As patterns like Iterator and Observer were built into libraries and frameworks, the Gang of Four catalogue's named solutions were absorbed so programmers used them unnamed; the idiom notion grew from this. The later idea is a refinement of the catalogue into framework-embedded practice.
Carried by Design Patterns (1994).
Idioms and Framework-Absorbed Patterns influenced by Pattern-as-Language-Deficiency Critique
The prediction that patterns would dissolve as languages gained features was borne out as many patterns were absorbed into languages and frameworks, motivating the notion of language-specific idioms. The absorption argument carried the critique's point into practice.
Carried by Peter Norvig.
Idioms and Framework-Absorbed Patterns grew out of Programming idiom
The notion that some patterns are specific to a language or platform was generalized into the idea of idioms absorbed by frameworks, so the general pattern fades into built-in practice. The idiom concept is the direct ancestor of framework-absorbed patterns.
Enterprise Application Architecture Patterns influenced by List of software architecture styles and patterns
Fowler's enterprise patterns build on the layering and separation-of-concerns vocabulary developed in architectural styles, organizing business systems into layers and coordinating web requests. The architectural pattern vocabulary supplied the larger-scale framing.
Carried by Martin Fowler.
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.
Pattern Language influenced by Pattern Language in Design Methods
The software design patterns movement, launched by the Gang of Four and earlier by Kent Beck and Ward Cunningham, explicitly took Christopher Alexander's pattern language format of context-problem-solution as its model.
Carried by Christopher Alexander; Erich Gamma; Design Patterns (1994).
Gang of Four Object-Oriented Design Patterns influenced by Pattern Language in Design Methods
The Gang of Four explicitly credited Christopher Alexander's pattern language as the model for their catalogue of object-oriented design patterns, adopting the form of named context-problem-solution entries. Their book's introduction cites Alexander directly as the source of the pattern idea.
Carried by Erich Gamma; Richard Helm; Design Patterns (1994).
Pattern Languages of Programs influenced by Pattern Language in Design Methods
The Pattern Languages of Programs conferences were founded explicitly on Christopher Alexander's pattern language concept, adopting his format of context, problem and forces for software design patterns. The PLoP series and its proceedings carried Alexander's idea into programming.
Carried by Christopher Alexander; PLoP.
Enterprise Application Architecture Patterns influenced by Pattern Language in Design Methods
Fowler's enterprise patterns book follows the Alexandrian pattern-language form: named problem, context, forces, solution, popularised for software by the GoF and the Portland pattern community. The catalogue format and the idea of composing patterns into a language came from Alexander's pattern language.
Carried by Christopher Alexander; A Pattern Language (1977); Martin Fowler.
Idioms and Framework-Absorbed Patterns influenced by Pattern Language in Design Methods
Software idioms and absorbed patterns inherit the Alexandrian pattern-language idea that recurring solutions can be named, described by forces, and composed. The pattern form used in software pattern catalogues descends directly from Alexander's pattern language.
Carried by Christopher Alexander; A Pattern Language (1977).
Pattern Language reacted against Design Methods Movement in Urban Design Theory
Alexander worked within and against the design methods movement of the 1960s, and his pattern language was a response to its systematic, decompositional approach, replacing method with a shared vocabulary of solutions. The movement's conferences and debates provided the setting in which his ideas took shape.
Carried by Christopher Alexander; Notes on the Synthesis of Form (1964).
Pattern Language reacted against Design methods in Environmental Design
The pattern language emerged as a critique of the design methods movement's procedural, optimisation-driven approach to environmental design, offering instead a participatory language of patterns. Alexander's shift from method to pattern was framed as a rejection of that earlier programme.
Carried by Christopher Alexander.
Pattern Language reacted against Systematic Design Methods in Design Methods
Alexander's pattern language defined itself against the systematic design methods of the 1960s, rejecting their attempt to reduce design to explicit procedures in favour of a network of concrete, situated patterns. His earlier Notes on the Synthesis of Form belonged to that movement before he turned away from it.
Carried by Christopher Alexander; Notes on the Synthesis of Form (1964).
Pattern Language influenced Architectural Patterns in Software Architecture
The software pattern-language tradition, which began adapting Alexander's patterns to programs in the late 1980s and 1990s, supplied architectural patterns with their catalogue form and the idea of a named recurring solution.
Gang of Four Object-Oriented Design Patterns influenced by Object-oriented programming in Programming Paradigms
The Gang of Four patterns are formulated in terms of object-oriented programming concepts such as inheritance, polymorphism and delegation, drawing on the Smalltalk and C++ practice of the 1980s. The catalogue codified idioms that had grown up within object-oriented programming.
Carried by Erich Gamma; Design Patterns (1994).
Gang of Four Object-Oriented Design Patterns influenced by Object-oriented programming in Software Engineering
The Gang of Four book grew out of software engineering practice with object-oriented languages, collecting recurring solutions observed in real systems into a shared vocabulary. It was written by practitioners within the object-oriented software engineering community of the early 1990s.
Carried by Erich Gamma; Design Patterns (1994).
Gang of Four Object-Oriented Design Patterns influenced Architectural Patterns in Software Architecture
The Gang of Four's 1994 object-oriented design patterns, themselves modelled on Alexander, were the immediate template for software architectural patterns, which extended the pattern catalogue from classes to system structure.
Carried by Design Patterns (1994).

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 PatternsRelated fields
Fields its ideas are linked to
- Design Methods 7 links
- Software Architecture 7 links
- Programming Paradigms 3 links
- Software Engineering 2 links
- Digital Design Theory 1 link
- Environmental Design 1 link
- Urban Design Theory 1 link
- Programming Languages 1 link
More in Software Engineering
- Computing Education
- Devops And Sre
- Formal Methods
- Open Source Software
- Requirements Engineering
- Software Architecture
- Software Engineering
- Software Evolution
- Software Process Models
- Software Testing
See where Design Patterns sits on the Map of Human Knowledge