I’ve always been a perfectionist. While I’ve learned to manage the tendency over the years, mainly through liberal use of the 80/20 principle, perfectionism is still a part of my personality and I still feel it all the time. This is especially true when I’m in builder mode: I want the thing I’m designing and building to be perfect and complete. I want it to stand the test of time. When I’m unable to finish something, as with the Athena project last year, it irks me for a very long time.
I spent a few days in Barcelona last week, and had the opportunity to visit the Sagrada Família, which is the closest thing we have in the physical world to perfect design. It’s a really spectacular sight to behold for so many reasons. While the medium couldn’t be more different than my own—architecture, stone sculpture, light, etc., versus software—I nevertheless felt very inspired by what I saw. Here are three ways that I feel my work was inspired and impacted by Gaudí’s masterpiece.
Thing #1: Completeness ⚪
The biggest thing that struck me about the Sagrada Família is how complete the vision is. It’s far more than just a building. Every aspect was considered, and everything is meaningful, starting with the site itself: right in the middle of the plain of Barcelona, equidistant from the sea in front and the mountain behind, and equidistant from the city’s two main rivers, to the north and the south. The main facade faces the sea, as Gaudí wished.
Then there’s the structure itself. The top of the tallest tower is just slightly shorter than the height of the two small mountains that rise in Barcelona because, as Gaudí famously said, the works of man should never attempt to rival works of God. In fact, as a friend put it later, Sagrada Família is the perfect basilica because, unlike every structure that came before, it’s not man’s attempt to hubristically convey the idea of man-made glory to God. Rather, it effectively does the opposite: it conveys man’s affection for God’s design (and, by extension, for God himself) by reflecting elements of nature itself.
Gaudí wasn’t beholden to traditional ecclesiastical design conventions, and deviated from them in major ways with Sagrada Família. The design is enormously complex, and there are effectively no flat surfaces, no right angles, and almost no straight lines inside or outside of the building. The columns are totally unique and aren’t seen anywhere else on earth. They branch to support the load, and they’re made of different kinds of stone, depending on the load each needs to bear. The simplest column structure is “that of a square base evolving into an octagon as the column rises, then a sixteen-sided form, and eventually to a circle” (per Wikipedia); the others are even more complex. This, combined with the color pouring through the stained glass windows, has the distinct effect of making the interior feel like being inside a forest. The “branches” from the “trees” even come together to form a “canopy” above, which has tiny points of light shining through, just as in a real forest. The differing stone material also causes some “trees” to be lighter or darker, as in a real forest. It’s hard to describe in words, but the effect is extraordinarily powerful the first time you step into the space and experience it—and it’s unlike any other cathedral I’ve entered.
Inside, there are four primary spires, representing the four apostles. The building’s design, while not symmetrical, shows incredible narrative balance. The two opposite facades, the Nativity and the Passion Facades, have totally different themes, representing the two most important aspects of the life and story of Jesus: one has warm colors and one has cold colors, one has summer fruits and the other has winter fruits, one has joyous imagery and the other painful imagery. The Nativity Facade faces east, towards the rising sun, while the Passion Facade faces west, towards the setting sun. There’s also elegant math at work: the columns separating the aisles are on a 7.5 meter grid, and all of the other internal distances are multiples of this: 15 meters, 30 meters, etc. The central vault is 200 meters tall.
The list of details goes on and on. Not satisfied simply with designing the building itself, and directing the art and sculptures, Gaudí even had a hand in designing the liturgical items—pews, candlesticks, the pulpit, benches and chairs, etc. His design extends from the choice of site and the foundation to the building itself, to the light that fills it, to the incredible assortment of art and symbolism, to the furniture it contains.
Everything has significance. Everything is connected. Literally no decision was made arbitrarily. This is a rare and extraordinarily powerful idea. So often, when we design and build things, we have certain goals in mind. We want to build an app that’s fun and engaging. We want to build infrastructure that’s performant and doesn’t consume too many resources, that sort of thing. We focus on the primary goal and lose sight of everything else. We sacrifice things to serve the goal. When the primary goal isn’t directly impacted, we make arbitrary decisions, often assuming we can test one thing and fix it later if needed.
With vanishingly few exceptions, we simply don’t design or build software the way Gaudí designed Sagrada Família. We don’t craft every element by hand; we use third party libraries for everything but the core business logic. We pay very little attention to what goes on under the hood. And we certainly don’t build software to run for hundreds of years.
It got me thinking, what would it look like if we designed and built software the way Gaudí designed and built the Sagrada Família? What if the vision was so complete? Would it even work? Would we ever ship any code? Wouldn’t the technology change so fast that we would be unable to keep up? It’s hard to say, but it’s an interesting thought experiment. The technology of architecture, structural engineering, and construction have changed enormously since work began on the Sagrada Família 150 years ago, but each generation of architects and builders has adapted to the new technology. Surely we could do the same with software.
Thing #2: Longevity 🧬
Gaudí knew from the beginning that he wouldn’t live to see his masterpiece completed. In fact, he knew he wouldn’t live to see the majority of the building finished. This had a big impact on the way he ran the project. Rather than taking a scattershot approach, spending some time on one part of the project, and then some time on another part, he instead took a very structured approach. He focused his efforts on finishing one part of the building: the Nativity facade and its four towers, in order that it would act as an exemplar for later architects and builders. (The facade wasn’t totally complete at the time of his death, but it was near completion.)
In my experience, one of the hardest things about designing and building something complex is task sequencing. It’s not at all obvious which order various components should be designed and built, especially in the beginning. And I can’t recall ever taking an engineering class that discussed this. Maybe it’s different for other forms of engineering, but this is especially true of software engineering—where you could, in theory, start anywhere, and mock the missing pieces. Unlike mechanical engineering or structural engineering, you don’t have pieces of a project that are literally relying on other pieces having been put in place correctly.
So task sequencing is more of an art than a science. And here, too, I find Gaudí’s example informative and instructive. When building applications, we software developers tend to focus on one part of the structure first: e.g., build the entire backend first, or build the entire frontend first, or fully design the API first. In fact, what Gaudí did was something different entirely, but something completely rational: build one entire feature at a time.
It’s a totally different approach to design and engineering from the one usually taken! Because building even a single, working feature requires touching literally every part of the stack: backend, frontend, networking, data, API, authentication, etc. It makes me wonder if this isn’t a better approach than the one we usually take to building software. Why? Because you’re more likely to find flaws in the design this way. The alternative, building the entire frontend with a particular backend design in mind, means only finding out much later when you actually try to build the backend that it won’t work, which often means going back to square one. In theory, a good design can help you avoid this sort of issue, but in my experience, in practice, more often than not you have to start building to figure it out.
This is one way in which Gaudí thought about longevity: namely, that the project itself must long outlive him in order to be completed. But he was also committed to designing and building something that would stand the test of time, something truly timeless. He succeeded in this regard as well.
It’s hard to put your finger on precisely the aspect of Sagrada Família that’s timeless. Maybe it’s the breadth and scope: I cannot imagine that humans won’t always be awed by something of this degree of grandeur, completeness, and perfection. Perhaps it’s the incorporation of timeless design motifs, like Bible stories and the forest theme in the interior, as I described above. Perhaps it’s the attention to detail and the human element: you can’t help but be moved when you look at the stone carvings because they’re so lifelike and so powerful. This is no coincidence: Gaudí used actual people, including some of his construction crew, as models for the carvings.
There’s another difference between stone and software. Unlike software, which is meant to be released in drips and drabs and constantly updated, a cathedral has no beta releases, no upgrades, no version control. You have to get it right the first time.
Gaudí designed the basilica to be complete from the beginning. This requires a completely different design and engineering sensibility than we’re used to in software. The building has to stand for a thousand years, whereas we usually think of apps in terms of months, or years at most, and that with plenty of upgrades. If we thought of software as a timeless monument, we’d probably build it quite differently than we do.
I don’t think every software project can or should be designed or built this way. It’s just not possible. But it can still serve as an exemplar, and there probably are examples—operating systems and blockchains are the most obvious, but maybe not the only ones—of software that can and, arguably, should be built this way.
The only software project I’m aware of that’s an exception is Urbit. I’ve seen the source code, all the way down to the bottom of the stack, and I’ve seen the incredible aesthetic and attention to detail in the code. Urbit is explicitly built to run for hundreds of years. I wish more software was designed and built this way. And I’ll be keeping this in mind the next time I put code to cursor.
Thing #3: Architecture 📐
One of the most famous ideas in architecture is that “form follows function.” The basic idea is that, while we want to make things beautiful and aesthetically pleasing, function must come first. If the design isn’t functional and structurally sound, the architecture simply won’t work, and it won’t matter how pretty the structure is.
While good architecture does a good job of uniting form and function so that, e.g., structural elements are incorporated into the overall design and don’t look out of place, the Sagrada Família takes this idea to the next level. It truly unites form and function in a unique and beautiful way. Every aesthetic element serves a purpose, and the “function” of the design is in turn hidden behind a beautiful facade.
The most striking example of this is the lack of external supports. All traditional Gothic cathedrals feature external buttresses or extremely thick walls to support the vaulted ceilings. The most famous example is the flying buttresses present on famous cathedrals such as the Notre Dame de Paris. Indeed, the original design for the Sagrada Família also featured external supports. It’s a big engineering challenge: you want to create a massive empty space beneath a huge, high ceiling, and everything is made in stone, meaning it’s incredibly heavy. How do you support all that weight without using thick walls or huge support beams inside the structure, that cause the space to feel closed and claustrophobic?
Gaudí found another way. In the museum below the basilica, there’s an exhibit that shows how the overall design of the structure evolved over time: it got bigger, and taller, and the inside actually became more open. Gaudí employed several techniques to make this possible, but the main ones are inclined, internal columns that tilt and branch to distribute load—the “forest of trees” effect—as well as the “twisting” hyperboloid and helicoid forms, both of which I described above.
I find the latter especially striking. These forms (see examples here) look almost biological in origin. That’s not a coincidence: Gaudí was inspired by biological designs, and biology and natural selection have indeed arrived at extraordinarily efficient, elegant designs for bearing weight in plants and animals alike. What’s truly remarkable is that, while structures such as these have become more common in recent years due to computer-aided design, and even AI-inspired design, Gaudí figured out parametric design a hundred years before any of that technology was available. He did it manually through a process of intuition, experimentation, and clever use of physical models, such as the famous hanging chain model, long before computer-aided design adopted similar techniques.
It’s also interesting to note that, while Gaudí had a complete design in mind, the design has continued to evolve over the decades and centuries as the structure continues to be built, as technology evolves, and as successive generations of architects and builders have taken the reins. The Sagrada Família therefore represents a truly living design: complete, and fully functional, but simultaneously never fixed, and evolving to keep up with the times. This, too, feels inspired by nature and biology.
What does all of this mean for software?
Unlike physical infrastructure, the “form” and “function” of software are usually totally separate. In the case of a building, the “function” of the structure is visible, at least partially: the foundation, the overall shape, load bearing elements such as support columns or a cantilever, etc. In the case of software, by contrast, the “function” is typically completely hidden “under the hood” on the “backend.”
It’s an interesting thought experiment to consider: what if this weren’t the case? What if we tried to build software in such a way that, at least partially, certain elements of the design that are usually hidden are instead made visible? While this could, potentially, have a negative impact on the aesthetics or even the usability, this doesn’t necessarily have to be the case. Inspired by Gaudí, what would it look like if this “function” were made visible and also integrated into the “form”? A good, simple example of this is a spinning “wait” icon, or a progress bar that shows the status of a request made to the backend. This sort of UI element makes an otherwise invisible backend operation visible in a manner that’s aesthetically pleasing, but also functionally useful. (See this Gaudí-inspired AI-generated UI mockup.) Could elements such as these be better integrated into the overall design, a la Gaudí?
With respect to biomimicry, i.e., using structures that are inspired by nature and biology in design, this is far more common in the material sciences and in physical engineering than it is in software, but it’s definitely possible to do this in software as well. Examples include genetic algorithms, artificial immune systems (common in anomaly detection, antivirus software, intrusion detection systems, etc.), and, of course, neural networks, which underlie all modern AI technology.
One idea that comes to mind is network topology, and in particular, the topology of peer to peer networks, a topic that’s directly relevant to my field of distributed systems and blockchains. We tend to use relatively naive designs, such as nodes connecting to whichever peers they happen to discover first, and “gossiping” messages as quickly as possible across the entire network (another biologically inspired design that, ironically, is based on epidemic diffusion). What if we studied the “network topology” of, say, a hive of bees or a colony of ants, and studied how they “connect” with one another and communicate and propagate information efficiently? (Apparently, I’m not the first person to think of this.)
Like Gaudí’s masterpiece, the design and engineering of software continues to evolve constantly, and the design is never completely done. There’s a deeper question here, too: how can we ship a design that’s complete and can stand the test of time, but that can also continue to evolve as technology and tastes evolve in parallel? This is something I’ll be thinking about for a long time—and I’m curious to hear your thoughts about it, too, if it’s something you’ve considered!