Listen: https://serve.buildtall.systems/1eaa865494c9d25194d7466f1075e3faf7a6711844c19615479a8877062725ac.mp3
Source: https://serve.buildtall.systems/aa4f9dd51ac51f8a5b017cf72b208c346e149a1bcc43bf9dd41a4974440e73d0.pdf
This episode covers "ON PATTERN LANGUAGES, DESIGN PATTERNS AND EVOLUTION", a 2019 article by Bruno Postle, an independent researcher in Sheffield, published in the journal New Design Ideas.
This is a conceptual article rather than an experiment. It argues from examples and reasoning and reports no dataset or measured results. The paper traces how Pattern Languages, the approach Christopher Alexander, Sara Ishikawa and Murray Silverstein set out in their 1977 book A Pattern Language, shaped software Design Patterns, and then asks whether that success could carry over to buildings and cities. Its answer is a proposal to grow building designs through simulated evolution, with a Pattern Language used as the fitness criteria. The paper describes this as part of a larger ongoing Free Software project, and it says the article is not the place to describe the implementation, which it refers readers to in earlier publications. The argument is clear and is illustrated with concrete examples, such as the pattern SOUTH FACING OUTDOORS, but the evolutionary proposal is not tested in this article, so the evidence for it is thin. The text does not state a funding source or a data availability statement. The front matter gives the venue as New Design Ideas, volume 3, number 1, 2019, pages 44 to 52, with publication on 28 June 2019. OpenAlex has no record of this document: no work in its index matches the title and authors, as of 17 October 2026, so this episode makes no claim about how often the article has been cited.
The introduction explains that this work provides context for a larger, ongoing Free Software project to design domestic buildings using simulated evolution. The author says the project is unusual because its design process is driven entirely by what are called Pattern Languages, with the aim that "the buildings should meet human needs at every scale". The resulting designs, the author adds, bear a strong resemblance to vernacular or traditional architecture.
The introduction says it will look at ideas about the built environment that sit outside the architectural mainstream but have long influenced computer science. The author wants to learn from that exchange between the two fields, with the aim, in the paper's words, to "make something genuinely useful for the built environment". The route is laid out in order: architectural Pattern Languages first, then the more successful offspring called software Design Patterns, and finally evolutionary computation. The paper says evolutionary computation "turns out to be an excellent match for Pattern Languages", with a Pattern Language taking the unexpected role of fitness criteria. In evolutionary computing, candidate solutions are varied and then kept or discarded according to a fitness measure, a score for how well each one meets the goal. Here the Pattern Language supplies that score.
The discussion then turns to architectural Pattern Languages. Writing from the perspective of a non-architect, the author calls the discovery of Pattern Languages in late twentieth-century architecture "one of the more interesting things to happen in architecture during the late twentieth century". Pattern Languages were originally described by Christopher Alexander, Sara Ishikawa and Murray Silverstein in the 1977 book A Pattern Language. In that approach, a pattern names a problem that recurs in the built environment and a solution to it, and the patterns are linked so that a designer can combine them into a whole.
The paper's central unit is the pattern, and it is careful to say what it means by the word. The patterns in the book it discusses "are not fabric or wallpaper designs, but solutions to typical everyday architectural problems." Each one is a guide to meeting a specific human need through architecture. The book is made up of 253 short chapters, laid out in what the paper calls a kind of early hypertext format. The idea is that a collection of patterns like these forms a Pattern Language.
Each pattern has a set structure. It makes a statement about one aspect of the built environment, pointing out a problem and suggesting a solution. It is then linked to related patterns that should be considered at the same time. The patterns are ordered by geometrical scale. City-level patterns, such as SCATTERED WORK, come first, and the smallest detail, ORNAMENT, comes at the back.
To show what a pattern looks like, the paper gives SOUTH FACING OUTDOORS. Its statement reads: "People use open space if it is sunny, and do not use it if it isn
t, in all but desert climates." The prescription follows: "Always place buildings to the north of the outdoor spaces that go with them, and keep the outdoor spaces to the south." It adds: "Never leave a deep band of shade between the building and the sunny part of the outdoors." The paper notes that south can be exchanged for north depending on where you are.
The paper's most important claim about these patterns concerns their status as knowledge. Unlike most of the rest of architectural theory, it says, patterns are "testable and falsifiable." A falsifiable claim is one that evidence could prove wrong. The paper says this makes the approach "a way of doing architecture as science," and it draws on work by Mehaffy and Salingaros to make the point. The consequence, in the paper's words, is that "we can and should expect that many of the patterns in the original book would be flawed and replaced over time with something better." The authors also note that there are likely many other, undocumented patterns for more obscure situations. A person facing a particular problem may need a special purpose Pattern Language, "adapted to the task in hand."
Finally, the paper observes that some patterns have very universal appeal. It cites LIGHT ON TWO SIDES OF EVERY ROOM and also brings in DIFFERENT CHAIRS.
The author describes the Pattern Language approach as a tool for judging, not a way of designing. "The patterns are not a design method in themselves," the author writes; they are "a guide for assessing a plan of action", for assessing possible designs, or for assessing finished places and buildings. The book has stayed in print for decades, which the author takes as a sign of its appeal. Yet practising architects rarely use it. At best it is treated as a historical curiosity, and at worst as too restrictive for artistic expression.
The author names two obstacles to bringing Pattern Languages into architectural practice. The first comes from what the author calls creative design. In that view, a designer takes in all available information, thinks hard, and produces a design as a creative act, so that the better the designer, the better the result. When architects tried to fit Pattern Languages into that framework, the results were unspectacular. Patterns seemed to make the process more complicated for little gain, so the author asks whether Pattern Languages are simply a poor fit for creative design.
The author notes that Alexander himself considered the book "incomplete or inadequate" and called it "my biggest failure". The author attributes part of the trouble to the book being read as a set of rules or instructions, which the author says produced crude or badly formed buildings. From the late 1980s, Alexander turned to morphogenesis, the step-by-step unfolding by which organisms develop, in which each part and each stage embodies what he calls "wholeness". That wholeness is expressed through fifteen properties that Alexander believed all things emerging this way possess. He concluded that this adaptive unfolding is as important for the built environment as it is in nature.
The second obstacle follows from accepting Alexander's patterns. If one does, the prevailing canon of architectural forms, including minimalist detail, bold geometric shapes, industrial repetition and monumental scale, starts to look like a set of "antipatterns". The author says many people find these forms creatively satisfying but argues that they do not meet human needs. The author warns that saying so can earn the label traditional, which is often set against modern. The author blames partly the language itself. Architectural modernism, which the author describes as a design fad from about a century ago, has come to stand for everything progressive, while resistance to it has come to stand for everything backward, conservative and Luddite.
For readers who want the humane, human-scale, ecologically sound environment that A Pattern Language promises, but who do not see themselves as either traditionalist or modernist, the author asks what to do. Alexander, the author suggests, implies that architects will have to change how they work, moving to an adaptive approach in which buildings evolve "through incremental changes", with the patterns as a guide.
The paper contrasts two approaches to design. One is the theory of Pattern Languages, which it describes as "largely neglected, disdained and sidelined". The other is the standard creative design method used in architecture, which the paper says "does seem to be a bit hit and miss". It judges that method by the quality of the cities around us, and offers a wry choice of explanations: there are not enough creative geniuses, the geniuses are not good enough, or, more generously, they are not given the opportunity to show their genius.
The paper then turns to computing. A reader with a computer science background, it says, may recognise the Pattern Language idea as similar to a major concept in object oriented programming called Software Design Patterns. The paper says the two "are directly related", and it cites Beck and Cunningham as the origin of that link.
Software Design Patterns came to wide attention through the book known as the "Gang of Four" book. It collected and codified a series of 23 patterns that had long been part of object oriented practice, though programmers had not necessarily named them as patterns. The paper says Alexander's influence is "all over this book", not only in the title, because the patterns follow a similar "name, problem, solution, consequences" structure.
The paper argues that this approach has lasted. Software Design Patterns "describe a very practical way of working", and they remain central to object oriented programming. Programmers discuss their projects in terms of patterns, even those who have never read the book. The paper's point is that "the influence of A Pattern Language is everywhere". It gives a concrete example: the first wiki was devised by Ward Cunningham specifically as a repository for these design patterns. So, in the paper's view, everyday tools such as Wikipedia carry the Pattern Language influence "running right through them".
Adaptation is central to software design patterns, the paper says. Adaptation here means taking existing solutions and reworking them for the problem at hand, because a specific problem has probably been met before. It also means building software by "starting with a small working system, and extending it", rather than implementing a grand design in one go. The paper links this to agile software development, which builds software through small incremental changes with continuous testing throughout. It warns that agile should not be confused with the management fashions that later borrowed the name.
Agile development, the paper explains, accepts that initial design specifications usually change during implementation, sometimes dramatically. It treats this as a normal condition rather than an exception. A less obvious idea from the same tradition is that, when making these incremental changes, it is often best to choose the change that makes future changes easier, rather than aiming directly at the goal.
The paper then asks how this success in software might be carried over to buildings and cities. Its reasoning is that architecture is where Pattern Languages began, so the question is "how can all this real success in the software industry be reapplied to buildings and cities?" The passage closes as the paper starts to set out the problem that this question raises.
The paper now asks whether the idea behind design patterns, familiar from software, could carry over to buildings. Its heading poses the question directly:
Design Patterns for buildings?
The author first sets out what makes software so easy to reuse.
Well constructed software is universal, it can be duplicated millions of times and still behave the same in different locations, on different operating systems, unexpected situations, and different hardware; it is modular, with consistent interfaces so it can communicate with, or substitute for, other software created by different people.
The author admits to having once been drawn to the obvious parallel. "Like a lot of people, I used to think" that buildings could have an equivalent: a mass-produced pod that could be moved quickly around the world, with pluggable services and interfaces. The author calls this "a very seductive idea." In that picture, pods could be swapped and assembled into larger buildings, and millions of them would form transient cities wherever they were needed, able to split and migrate and leave no trace behind. Taking the software comparison further, the author imagines an open source architecture, in which designs for the pods would be shared and improved collaboratively, then rolled out worldwide using modern manufacturing techniques.
The author then sets out why the comparison fails.
But buildings are not the same as software, buildings are specific and software is generic, every building has to exist in an actual location which is different to a finite number of other locations.
To make the point, the author uses the operating system kernel of the computer on which the text is being typed. It carries driver modules for vast numbers of obscure hardware, most of which will never be used, so that it works anywhere without tedious configuration. This works because, as the author puts it, "for software, space is cheap and all distances are small." Rarely used modules do not get in the way, because they do not add distance to the drivers that are actually in use. The author calls this a "one-size-fits-all philosophy" and sets it against the situation of buildings.
The author imagines wanting a house built along the same lines: a big kitchen, many bedrooms for guests, room to park a removal van on arrival, a home cinema, a tennis court, perhaps two, and a landing pad for a helicopter the author does not yet own. Such houses do exist, the author notes. But these features are not only costly; they take up real space, and just by existing they lengthen the travel distances within the house. Where every house is built this way, residents have to travel past a great deal of other people's belongings to get anywhere.
For buildings, not only is space expensive, but distances are critical.
The author stresses that
Distances for people tend to be very significant.
Where space is sparsely occupied, journeys are longer, which brings additional costs and other negative effects, a point the author supports by citing earlier work on urban design.
On efficiency, the author draws a sharp line.
Software is useful when it saves people from doing repetitive or unnecessary tasks.
Efficient buildings, by contrast, are packed closely together and use the least space and materials for the most utility. The degree of modularisation, the author argues, is largely irrelevant to that utility, and because every site is specific, "modularisation can only ever have detrimental effects on the use of space." A generic pod-room or pod-house, on this account, will always be just a little too big, or too small, or the wrong kind of shape. In software the reverse holds: "Efficiency in software comes from modularisation and mass duplication," and the space that the duplicated software takes up is largely irrelevant.
The 1987 paper by Kent Beck and Ward Cunningham is worth going back to, because it differs in an important way from what came after. The pattern language it presents is for a graphical windowing application, and its patterns describe arranging windows on a screen. The author notes that this is very much like arranging parts of a building on a plot of land, and that the debt to Christopher Alexander's A Pattern Language is clear.
But the author points out that software design patterns did not find their success in graphical user interfaces. None of the patterns in the Gang of Four book, the influential 1994 catalogue of software design patterns, are about placing widgets on a screen. They are about how software components are wired together behind the scenes.
The author argues that this distinction explains why the pattern approach has worked so well in software engineering. In software, there is a very direct relationship between the problem and the solution. As the author puts it, "the solution is simply the right way to do it for any particular situation." If two software patterns conflict, with an overlap in functionality that means neither can be implemented in full, then "this is a sign that you are doing something wrong."
Buildings do not work that way. A building has a finite amount of space in which everything has to happen. Putting one pattern into that space requires an intervention, such as a wall, a door or a window, and that intervention inevitably gets in the way of some other pattern that needs the same spot. The result is "a constant trade-off, a process of give and take that necessarily results in compromises." Every real built space is the product of a balance between needs and costs, and so, the author says,
if we are building with a Pattern Language, then each pattern can never be implemented in full.
The author makes the same point about screens. Successful software design patterns are generally not about the graphical user interface, because a computer screen is a limited space that demands compromise, much like a building plot. That is the reason the author gives for the gap between the two fields.
The author then asks what Free Software practitioners could contribute: "what can we bring to the design of buildings and cities that is fundamentally different from architecture as we know it?"
The next part of the discussion turns to adaptation. The author summarises A Pattern Language as a book that "sets out a path leading to a built environment that is humane and human-scale." The approach was devised for creating buildings and places, yet it has been far more successful in the software industry, and the author says its influence in the architecture profession is "somewhere near zero." The author asks whether pattern languages could ever have the impact on the built environment they were intended to have.
The author's answer is that pattern languages are a solid foundation, but that modularisation is not the answer. Modularisation here means "creating libraries of refined reusable designs like we do with software," and the author says this is not a good solution to the problem. Software design patterns are, in the author's view, basically the same thing as pattern languages. Their success in software does not automatically carry over to helping people build real buildings.
The author then returns to adaptation, which is central both to Alexander's practice as an architect and to agile software development. Adaptation has a specific meaning in this argument. It is "a process of evolution through incremental change," and the author asks the reader to see it as different from invention. The discussion of that distinction continues beyond this point.
The paper next draws a distinction between two kinds of creative process. It helps, the authors suggest, to think about "which processes are adaptive and which are inventive." Adaptive processes are the kind life undergoes. The authors describe natural selection in Darwin's terms: "organisms that are the best fit for the environment are the organisms that go on to produce the next generation." The environment shapes living things through selection, and even when people breed domesticated animals and plants, the authors say human interference is just another part of that environment. "Evolution in nature happens through small incremental changes," and no inspiration is involved. Inventive processes, by contrast, depend on inspiration to create something new.
The authors then bring this distinction to architecture. Pattern languages, the collections of design patterns that Alexander proposed for building, "require an incremental, adaptive, approach." The difficulty is that a decision about any single building "involves balancing potentially dozens of patterns." Each choice can have consequences beyond the task in hand, and designers must make such decisions again and again. The authors contrast this with designing from a grand creative concept, filling in the details later and ignoring the parts that do not quite fit. They note that this approach "leads to all too many failures in our built environment."
In software terms, balancing many interacting variables is an optimisation problem. The authors point to evolutionary computation, a family of methods for hard problems that follows nature's example. Rather than changing a single candidate, it works with a population of individuals, subjects them to simulated environmental pressures, selects the better fit, and repeats the process, so that the next generation is usually a better fit for the environment.
The authors then put forward a proposal. They ask:
Can we create software that designs buildings in an evolutionary way using Pattern Languages as fitness criteria?
They sketch the idea further. The steps needed to unfold a building could be described by a kind of genetic code, which could be mutated or crossed with the code of other buildings. These buildings would be placed in a simulated environment made of a pattern language, daylight and the surrounding landscape. The authors ask whether this would be enough to begin "designing a humane, living environment, as promised by A Pattern Language?"
They also ask whether the process of building evolution could be controlled so that the building is whole at each step. That would have to take in Alexander's fifteen properties alongside the pattern language, with the purpose or use of rooms as a secondary consideration. The authors acknowledge that this reverses the usual order, since allowing function to follow form "would run counter to accepted architectural practice." Their justification is that buildings which have survived for centuries have often seen the use of individual rooms, and even the purpose of the building, change many times over their lifetimes.
The discussion closes by pointing to a question the paper leaves open. A pattern may be a close fit for its purpose, but it may also be a close fit for general human use, for the immediate environment, for daylight, and for a good geometrical shape. The paper calls this “a suitable topic for further investigation.”
The conclusion sets aside the practical side of the work. The author writes that “this article is not the place to describe the work that has been undertaken to implement these ideas,” and points readers to earlier publications by the same author for that account.
The paper’s verdict on the wider field is split. Pattern languages, it says, “have already proven to have a profound contribution to the computer science field.” Whether the book A Pattern Language will have the same influence on architecture and the built environment that it was originally meant to have, the paper says, “remains to be seen.”
The paper ends with two long passages from the architect Christopher Alexander. In the first, he asks why computer scientists and software engineers should suddenly be responsible for the form of the built environment, and answers that it ought to be the province of architects, planners and engineers. He warns that those professions are not taking responsibility for what he calls the generative approach to living structure.
Therefore it will fall to someone else to do it instead.
In the second, which comes from a 1996 paper, Alexander tells computer scientists directly:
I want you to realize that the problem of generating living structure is not being handled well by architectural planners or developers or construction people now, and the Earth is suffering because of it.
He argues that the methods those professionals use cannot solve the problem. The generative process, he says, is natural to people in computer science, because it forms the core of their field. The methods they use every day in software design, he suggests, are well suited to the task.
So, if only you have the interest, you do have the capacity and you do have the means.
The paper's main takeaway is that Pattern Languages worked well in software, where code can be copied at almost no cost and distance barely matters, but that buildings are specific to their sites and every pattern has to compromise with others for the same limited space. Its proposed way forward is an adaptive, incremental approach in which buildings evolve, judged against a Pattern Language. The limits the paper states are its own. It does not describe the implementation of the software it has in mind. It leaves open whether A Pattern Language will influence architecture as it did software, which in its words "remains to be seen". It also leaves open whether a pattern that suits its purpose will also suit general human use, the immediate environment, daylight and a good geometrical shape, which it calls "a suitable topic for further investigation". The paper's wider verdict is that Pattern Languages "have already proven to have a profound contribution to the computer science field".

