So I’ve been reading some Richard Gabriel. ( Richard P. Gabriel - Wikipedia and Dreamsongs Site History ) He’s a MIT AI Lab / Common Lisp person with PARC connections and so stands at the intersection of Lisp and Smalltalk, and is also one of the few people with links to the “Software Patterns” movement who actually reads and understands the late Christopher Alexander, the inventor of the Pattern Language concept.
I’ve read some raw Alexander, too (although I’ve only skimmed rather than deep-dived the four volumes of The Nature of Order) , and so I have Some Questions about Alexander’s approach to architecture/design, as opposed to how the Software Patterns people interpreted his work.
Oh, I also used to hang out in the mid-2000s on the Portland Patterns Repository Wiki (the original Wiki, Ward Cunningham’s one), which led to me getting very confused about Best Practices in Software Development. (The PPR Wiki community, paradoxically, was full of people who were very critical of the Patterns movement and of Object Oriented Programming itself.)
Anyway. Here’s the deal. Here’s one of the things that I’m currently very confused about:
The Software Engineering community, including the Object Oriented movement and the Patterns movement that arose from it, likes to think in terms of what I’m going to call modules. (The module concept, I believe, is much older and broader than the object concept; it was Wirth’s big thing, for example). A Module is a sealed box with clearly defined interfaces. The wisdom everyone agrees on is that a System must be built from Modules. Modules should have clean separation of concerns; if the modules are Objects then they should have high internal cohesiveness and low external coupling (if I remember my terms right). The Software Components movement was different to the Modules movement, taking inspiration from electronics, but roughly the same idea. The Containers and Microservices movements (the current hotness) is Modules applied to the Cloud. In networking protocols, we talk about Layers but they seem to be just Modules at a slightly different level of abstraction.
Even good old 1970-era C can do Modules, in terms of compilation units (source or object files). Lisp has been doing Modules as closures since the 1950s; there’s probably a paper somewhere arguing that “Lambda is the ultimate Module”, and if not there should be. Node.js literally implements its module system via Javascript closures.
Modules might or might not have anything to do with the Types beloved of the FP/Haskell functional programming world, but if you have types, then a Module should be able to define and export them and not expose all of the implementation. And whether or not there are Types, Modules can and should be tested as units, and then tested again as integration tests.
So we’re all agreed. Functional and Object-Oriented people, Static and Dynamic evangelists, Late-Binding or Early-Binding enthusiasts- everyone agrees that Modules, modularization, and cleanly separable interfaces, are where it’s at in software engineering.
Great. But here’s Christopher Alexander, not a software engineer (although he actually was a mathematician, and a programmer before and during being an architect-turned-mystic), whose ideas were adopted by the Object-Oriented crowd (a subset of the Modules movement).
And the thing is, Alexander’s thinking is all about how Modules Are Not Where It’s At. He wants us to think in terms of something entirely different: Centers.
Alexander’s first draft of his theory is “A City Is Not A Tree” (1965), spinning out of his “Notes on the Synthesis of Form (1964)”. Richard Gabriel has some thoughts on Notes here: https://www.dreamsongs.com/Files/NotesOnNotesExpanded.pdf
Essentially, as I understand it, Alexander in 1964 was trying to act like a good Engineer, and decomposing a physically-built city or a community (an Indian village, in one example) into what I would call Modules and what he calls Trees. Cleanly separate clusters of tightly cohesive concerns, loosely separated…
And he finds he can’t do it. What he finds instead - and the thought that powers the entire rest of his career - is “deep interlock and ambiguity at all levels”. He finds not trees but “semilattice” structures - what Ted “Xanadu/hypertext” Nelson would call “intertwingling”. He looks for a precise method to design and while he summons lots of mathematics (fractals, chaos theory) the best he can do is to call us to feeling and “life” and “The Quality Without A Name”.
In Alexander’s later works, he manages to focus the ambiguous intertwingling-ness of Good vs Bad architecture into something he calls a Center.
A Center is the closest thing in Alexander’s thought to what Alan Kay would call an Object. Yet I believe a Center is not an Object and it is certainly not a Module.
A Center in Alexander’s thought might have a boundary, and is “strengthened by” having boundaries, but it is not defined by its boundary. The boundary is ambiguous and permeable. If the boundary is completely sealed, the system dies. There might be interfaces, there probably are, but the life of the system is somewhere else. And there is deep ambiguity, everywhere, about what is or is not part of a Center. Centers overlap, fundamentally. Their beingness is shared. Without this sharing, the whole cannot exist.
This doesn’t seem to be how Modules - or systems built from Modules - work, at all. A system built from Modules - a “clean”, “secure”, “clearly separated”, “well-designed” system in 2020s Software Engineering terms - seems to be what Alexander (and all modernist architects) thought of as good architecture in the early 1960s, but by the end of that decade Alexander had recoilled from in horror as the ultimate in Non-Life.
And so here’s my confusion. As we continue to try to apply what we think of as “good software architecture”… are we actually doing very bad architecture?
Alan Kay’s thought almost approaches Alexander’s in how mystical he actually is, when you read him directly. Both Kay and Alexander draw deep inspiration from biology, especially a biological cell. Judging from the constant sense of frustration and disappointment in his 2020s writing, Kay’s actual, inner, not-clearly-expressed vision of an “Object” probably is closer to a Center than to whatever it was that an Object became in Smalltalk and C++. But Alexander’s Centers seem much more themselves, a much more unique and worked-out vision, even than Kay’s Objects.
The thing that gets me the most is, where’s the ambiguity and overlap in Software Objects?
Obviously we don’t want a certain kind of “ambiguity” - we have a trust and security crisis in software as it is, we don’t need our software to be less trustworthy! Our current situation is a bit like our actual bricks randomly exploding: we don’t need more of that. But what is it that Alexander’s Centers are about, how do we “feel the sense of life” in a software system, what kind of software entity is it that can interpenetrate and overlap itself, that is strengthened by boundaries yet not defined by them, that can be both positive and negative space at once?
The thought that strikes me the most about a Center is that it’s more like a temporary yet self-reinforcing solution in design space than it is a physically existing thing. A Center is something like a “habit” or “tendency” that expresses itself in a built environment. It’s a synergy, a sweet spot, a confluence of forces. It’s something you notice only from close observation and from living in a system (“eating your own dogfood” in software terminology). It’s a gameplay loop, in game design. It is possibly something along the lines of “a definition that can fit on a page” or repeated interaction motif. A Pattern, yes, but not something that can be reduced to a Pattern.
Does Kays’ vision of Objects lend itself to creating strong Centers in built software system? Does something other than Objects lend itself better to creating strong Centers? Do Data-Driven, Functional, or Logic Programming metaphors possess more of that unnameable quality of “deep ambiguity and overlap”, the “messiness” that pervades Alexander’s sense of Life in a built space?
I feel that Malleability is very close to the idea of the Center, as well. Alexander’s sense of building (as well as Kay’s) seems to be strongly about the user changing the residence from within. So there must be some connection between Kay’s Objects and Alexander’s Centers - even though the Center does not, itself, appear to be a Module.
This is the question that bugs me at the moment.