Hugh Whitehead – of Foster and Partners – applied the following warning label to this book – and to parametrics in general – “Drink deep – or taste not.” This warning is meant to be foreboding, challenging, or both. I take it as all three. In the past few years, some proponents of parametrics have become rather evangelical. As with any burgeoning orthodoxy, there will be those who would pull the evangelicals back from extreme positions. And there are certainly others – I would probably lump myself in this category – who see the current arc of parametrics as trending toward “managing complexity” …as banal or important as that may prove to be. Whatever your position, it’s very comforting to be reminded – as Rob Woodbury does in Elements of Parametric Design – that parametrics is a design behavior. AND it’s a behavior you can study: there are patterns (in the Alexandrian sense) to be cataloged and documented. Not only that, these patterns predate a computational substrate. In this light, defining parametrics is about as meaning(ful/less) as defining sketching. More on that in a minute…first things first…
Elements of Parametric Design aims to be many things to many people. Rob Woodbury speaks to practitioners, students, teachers, and software developers – a very broad group. The book also aims to be concise and readable…it is both. Woodbury is a self-professed fan of Strunk and White’s The Elements of Style. Understanding this, one can calibrate expectations accordingly. I expected the book to be both descriptive and normative…and again: it’s both. I like books that are normative in a non-limiting way. In order words, they tend to say: “This is how people who are good at x do what they do…deviate at your own risk.” (Normative: check.) But they do not say: “Don’t deviate!” (Non-limiting: check.) Parametrics, like Woodbury, implicitly encourages deviation from the norm…but back to sketching first…
Sketching as a “skill” is sometimes thought to be lost with the adoption of algorithmic models of thinking, acting, and making. I have frequently heard the mournful tone of those who worry about the “loss of the hand of the architect” (I’m paraphrasing of course) with the use of any sort of parametric approach in dealing with form (why is it always about form?). It’s as if we stop sketching when we adopt a computational tool. Quite the opposite. Woodbury gently pokes fun at the “2B Religion.” He does so in good humor, while being sensitive to the notion that “sketching with code” is rather new to the architectural discourse. It’s certainly not new to other areas of design: interaction design, for example. Woodbury echos one of my favorite recent takes on sketching: Bill Buxton’s. Buxton’s enumeration of the qualities of sketching in Sketching User Experiences are just as applicable to parametric thinking as they are to “traditional sketching.” Woodbury argues that “sketching with code” – the ability to capture ambiguity, to explore, to adapt to change – is at the heart of parametric design. Parametrics within design systems, as Woodbury point out, are not new to computing….
The book begins at the beginning: Ivan Sutherland’s SketchPad. Most readers will be familiar with SketchPad, but it’s always worth revisiting. The action starts around 8:25 in the video:
Starting from Sutherland’s work as a (very common) point of departure, the first two chapters of this book trace the intellectual and technical history of parametrics within design computing, talking about how designers use parameters and the skills and strategies employed in doing so. I will not delve into these chapters in detail, because they must be read to be fully appreciated. Regardless of your level of interest or particular perspective, I highly recommend reading the first three chapters of this book even if you go no farther. Of course, I suggest you keep reading…
Chapter 4 is on Programming. This chapter, along with the Geometry Chapter (6) are the most dense parts of the text. Woodbury makes some observations about how and why architects learn to program. If you are a designer who is new to programming or one who codes regularly, this chapter is a decent introduction or refresher, as the case may be. Woodbury does touch on the principles from The Manifesto for Agile Software Development (Beck et all, 2009) on Pg. 66, which is worth reading. (Though there may be analogies to be draw between Agile development and parametric approaches to design, there’s nothing – to my knowledge – quite like Agile development within the architectural practice. Software architecture, yes. Architecture as in buildings? No.) If you are an experienced or “amateur” programmer, you may want to skim this chapter.
Chapters 5 and 7 are by two practitioners: Brady Peters and Onur Yuce Gun, respectively. I’ll come back to Chapter 6 in a minute, because these two chapters stand out…
In Chapter 5, Brady Peters discusses the New Elephant House by Foster and Partners at the Copenhagen Zoo. Peters explains that this building was neither pre- nor post-rationalized, but it does seem quite convenient that a rotated torus slice rationalization was appropriate. I suspect this was not the happy accident that Peters makes it out to be: “Ironically, once discovered, the form’s geometric simplicity meant the designers could choose either computational or analogue tools in further work” (Pg. 72). Physical models played a crucial role but, as the design progressed, a more “descriptive solution became necessary.” However it all went down, the parametric strategies employed are beautiful and graceful: 1) a structural generator controlled the 26 variables driving the canopy subdivision; and 2) a frit generator created variable density percentages of leaf patterns as a function of location in the glazing grid. I loved the description (Pg. 74) of the “Geometry Method Statement” that Foster and Partners delivered to the fabricators on this project.
In Chapter 7, Onur Yuce Gun describes KPF‘s design for White Magnolia Tower and the competition entry for the Nanjing Station South. The chapter is interesting in that Gun walks us through both post-rationalization (White Magnolia Tower) and pre-rationalization (Nanjing Station South). With post-rationalization, KPF started with the shape that they wanted, then generated shapes that were like it and evaluated each in terms of cost and similarity to the original design. In the case of the Nanjing Station South, it was pre-rationalized by the constraints of defining S curves that limited the overall geometric outcomes of the model. The contrast of the two methods is instructive when explained back-to-back. For this reader, the chapters by Peters and Gun provided concise and candid case studies of how parametrics were deployed to manage complexity without over-simplification of the architecture. It is slightly unfortunate that both projects (New Elephant House and White Magnolia Tower) made use of torus slices for quadrilateral panel rationalization. Of all the diversity of geometric forms, we get two very similar strategies. Unfortunate? Yes, but this pattern should not put the reader off…if anything, it reinforces the messages in Chapter 6 and shows how basic underlying geometry often dictates the game.
Chapter 6 – Geometry – is the most dense in the entire book. My suspicion is that most readers will skim and return to the information when needed. I doubt this would bother the author; he seems to know that most of his readers will bump up against each of these geometric relationships in practice (if not in theory) at one point or another. Many readers will want more examples of how each concept is typically used in parametric design, but most of the principles “covered” are far too general. In a sense, this chapter is rather like a condensed version of Architectural Geometry (Pottman, Asperl, Hofer, Kilian, 2007), to which interested readers should probably refer for such examples. That said, there are some very nice diagrams of Bezier curves (Pg. 148) and a wonderful property sheet of each geometric representation type (Pg. 167).
I have been a fan of Woodbury’s research group’s designpatterns.ca site (which is now the book’s site) since I heard about it from a friend about 3 years ago. Chapter 8 – a substantial portion of the book – is a printed version of the website (just without the downloads: go to the site for those). The patterns are rooted in the SmartGeometry community. I have benefited from attending a couple of these conferences and have heard Rob Woodbury speak more than once, so I knew what I was getting myself into when I opened the book. I knew the examples would be rooted in Bentley’s perspective on parametrics. They are, but I immediately appreciated Woodbury’s evident aim to generalize the patterns beyond a single software, as tied they may be to GenerativeComponents by inclination or circumstance. I am also a GC user (however frequently I use Grasshopper nowadays), but reading Chapter 8, I started to miss GC. For me, revisiting these patterns was a nice reminder that the constraints of the software itself can be freeing. While the explicit writing of Controllers within GC may seem hardcore, constructing them from scratch encourages a tight coupling between the Controller and the task. In Grasshopper, I tend to rely on nodes like sliders, graph mappers, etc. as my controllers. In so doing, I probably limit myself. Regardless, the patterns that GC engenders are not specific to GC alone (just certain styles or modes): the Grasshopper version of the Design Patterns site (hosted at CMU by Tsung-Hsien Wang and Professor Ramesh Krishnamurti) is an excellent “translation” from transaction to definition. I appreciate that the SmartGeometry community is becoming software neutral.
The final chapter – by Mehdi (Roham) Sheikholeslami – is on a concept called “hysterical space.” Hysterical comes from hysteresis, or path dependence. (I love that choice of terminology…you can explain the etymology all you like: it’s still hysterical). It’s a concept of generating, storing and visualizing the explored (and unexplored) design space. Sheikholeslami outlines a method of defining such a space and a representation scheme (and a sort of interaction history) employing a recorder pattern. The Dialer (Pg. 286) is notable just as an interesting representation/graphic. Hysterical space is a cool concept – though I wonder what happens (from a computational, interactive, and visual perspective) when the space gets very very large – but the topic is an abrupt ending to the book. Not that the discussion of hysterical space is uninteresting, it’s just a somewhat anti-climactic ending. My main criticism of this book that that it might have done well with a conclusion that goes beyond the search of “design hystory.”
In sum, Elements of Parametric Design lives up to its promises. If you are a beginner, then you will get the lay of the land at this particular point in design history and have a good idea where to begin. If you are a designer already steeped in parametric practice, this book is a quick read and a welcome synthesis of many things you probably have already experienced. Further, the book will serve as a great catalog of core concepts and patterns: I suspect you will be turning back to the geometry chapter occasionally when you want (need?) to be reminded of exact formulas. If you are a teacher, you’ll get a firm grounding in the theory, but also a candid look at the realities of satisficing (satisfy + suffice), something you will want to encourage in class as it will increase your “incluence” (include + influence). If you are a software developer, you might get inspiration the clarity of established patterns and from their limits. Finally, if you are a designer who is still skeptical about parametrics, but is curious about the advantages and tradeoffs, this is a great book for you. Of all the works out there on the “revolutionary nature of algorithms,” Elements of Parametric Design will convince you to “drink deep” without fear of losing your senses.
P.S.: A sincere thanks to the author for writing a book full of diagrams that are perfectly clear to a red/green (deuteranomaly) colorblind reader like myself.