Design patterns are a cornerstone of modern software development—but they didn’t start in programming.
Originating in architecture, the concept of “patterns” was created to solve recurring design problems in buildings and cities. Decades later, these same principles were adopted by software engineers to tackle recurring coding challenges. In this post, we’ll explore where design patterns came from, how Christopher Alexander inspired their use, and how they shaped the foundations of object-oriented programming.
In 1977 and 1979, Christopher Alexander, a professor of architecture, and his colleagues at the Center for Environmental Structure in Berkley published the two books: A Pattern Language and A Timeless Way of Building. He himself described both books as connected parts of joint work.
In the first book, A Timeless Way of Building, Alexander describes the theory behind the creation and use of what he calls a pattern language. In the second book, A Pattern Language, he provides a concrete form of a language for describing architecture.
First, Christopher Alexander’s aim was to enable anyone to use the model catalog, which had been developed over more than eight years of architectural work, to design or improve a city, a house, or an office. Secondly, he describes how anyone can develop their own language—either from completely new descriptions or by combining existing approaches. For A Pattern Language, he explicitly emphasized that the emphasis is on the word “A,” i.e., it is only one form and that the compilation is not to be understood as complete and universally valid. Anyone should use the patterns, develop them further and share them themselves so that the architecture can continue to evolve.
For the sake of simplicity and ease of understanding, he proposed a uniform structure for the patterns, as he called the descriptions, and described 253 patterns on a total of 1220 pages in his work. Only successfully applied patterns were included.
Each of Alexander’s patterns contained the following blocks in a fixed format:
Christopher Alexander used strict formatting rules for the patterns. For example, three asterisks (***) separated the individual blocks of the patterns. No subheadings followed.
The individual patterns were also “weighted” with star ratings to indicate how mature and how practicable a pattern was and whether there was still room for improvement.
Alexander divided the patterns in the resulting catalog into three subgroups. Each group refers to a level of abstraction in architecture.
The first set of patterns in the catalog described large-scale structures for entire cities and communities. The second category of patterns present solutions for the arrangement of houses, and the third group dealt with the construction of houses.
“The fact is, that we have written this book as a first step in the society-wide process by which people will gradually become conscious of their own pattern languages, and work to improve them.” —Christopher Alexander, A Pattern Language, 1977
How Design Patterns Entered Software Development
For a long time, these descriptions and terms for patterns or pattern catalogs had nothing to do with software development. Ward Cunningham and Kent Beck first popularized the concept of patterns in software development in the 1980s. They worked together at Tektronix where they used the object-oriented programming language Smalltalk. At that time, they could not find good instructions for learning or writing down the associated object-oriented way of thinking or the use of terms from object orientation.
The book by Christopher Alexander, which was sent to Ward Cunningham by his student friend William Croft, gave Cunningham and Beck the idea of closing this gap by merging the world of architecture with the world of software development and adapting the concept of patterns and the pattern languages.
In September 1987, their presentation on Using Pattern Languages for Object-Oriented Programs at the OOPSLA (Object-Oriented Programming, Systems, Languages & Applications) conference in Orlando, made this idea more popular.
The presentation introduced Christopher Alexander’s idea of a pattern language and its possible applications in software development. Also, part of the presentation were the first five numbered patterns for object-oriented user interface development:
Cunningham and Beck already announced in the description of their presentation that they had identified and outlined a further 20 to 30 patterns and that they wanted to publish these in their own pattern language with around 100 to 150 patterns:
“We have completed approximately ten patterns, have sketched out 20-30 more, and expect our finished pattern language to contain about 100-150 patterns. Our initial success using a pattern language for user interface design has left us quite enthusiastic about the possibilities for computer users designing and programming their own applications.” —Kent Beck and Ward Cunningham, OOPSLA Conference, 1987
Subsequently, the concept of design patterns spread further in the world of software. In 1991, in Zurich, Erich Gamma laid the foundation for the book Design Patterns with his doctoral thesis entitled “Object-Oriented Software Development Using the example of ET++: Elements of Reusable Object-Oriented Software,” coauthored with Richard Helm, Ralph Johnson, and John Vlissides in 1994.
This group of authors has since been called the Gang of Four (GoF) because of its size. The patterns listed in their book are therefore often called GoF patterns.
The Gang of Four consists of the following members:
Patterns are grouped or classified according to their intent and area of application, in the same way as Christopher Alexander had done.
Even before the Gang of Four’s book was published in 1994, another group met in August 1993 at the invitation of Kent Beck and Grady Booch in a mountain hut in Colorado to further explore the idea of design patterns. The participants of this meeting wanted to build upon the basic work of Erich Gamma’s dissertation and develop a more reusable approach to generic patterns. Their work provided the basis for the later Gang of Four book.
This group also went down in history as the Hillside Group, in reference to the location of the meeting.
The Hillside Group met in 1993 and consisted of the following individuals:
The Hillside Group is now registered as a non-profit educational organization that sponsors and organizes various conferences. It promotes the use of patterns and pattern languages so that knowledge can be recorded, analyzed, and shared easily. According to its own mission statement, the goal of the group is to improve the quality of life and society as a whole.
With the publication of Design Patterns: Elements of Reusable Object-Oriented Software by the Gang of Four, design patterns have become widespread in software development. This work is considered one of the most widely used and important books on the subject of software design.
Christopher Alexander’s basic concepts for problem solving in architecture were subsequently adopted by various software developers who developed and published their own pattern languages.
Even though object-oriented languages were at the forefront of the development of design patterns in software development, the basic concept is not limited to this intent. Design patterns have always been used (and still are) to describe corresponding problem solutions in other contexts or languages.
Patterns always outline a successfully applied problem solution, and over time, four components have become established that every pattern description includes as a minimum:
Note that patterns do not represent a concrete form, they're “only” an abstract template with which the initially described problem can be solved.
In many people’s minds, GoF patterns are closely associated with Java development. However, Java was not published until 1995/1996, that is, after the Gang of Four’s book had been published.
Their book therefore contains no Java examples, only C++ and Smalltalk examples.
The figure below shows the chronological sequence of this development.
From Christopher Alexander’s architectural blueprints to the Gang of Four’s groundbreaking book, design patterns have traveled a long path. What began as a method for shaping buildings and cities became a universal way to describe problem-solving in software. Today, whether you’re working with Java, C++, or modern frameworks, design patterns provide a shared language that helps developers create reusable, maintainable, and scalable systems. Understanding their history helps us appreciate why design patterns remain an essential tool in software engineering.
Editor’s note: This post has been adapted from a section of the book Software Architecture and Design: The Practical Guide to Design Patterns by Kristian Köhler. Kristian is a software architect and developer with a passion for solving problems using efficient, well-structured software. He is the managing director of Source Fellows GmbH.
This post was originally published 10/2025.