There seems to be some layering rhythm to how software capabilities are harnessed to become applications. Every new technology tends to grow these four layers: Capabilities, Interfaces, Frameworks, and Applications. There does not seem to be a way of skipping or short-cutting around this process. The four layers grow with or without us. We either … Continue reading “Four layers”
I’ve been talking about pace layering a lot, within the dandelions and elephants story and in other pieces. Here’s yet another way to apply this framing. One thing that stood out to me was this notion of a common force that animates their formation. Here’s my guess: this force is the desire for predictability. For … Continue reading “Pace layers of predictability”
I’ve been writing a bit more code lately, and so you’ll notice that some of my stories are gravitating that way. Here’s one about layer gaps. Layer gaps are when a developer surface layer fails to close fully over the layer below. Another way of saying this is “leaky abstraction”, but I’ll use my own … Continue reading “Layer gaps”
Here’s a riff on the “hourglass model” conversation I’ve had with Bernhard Seefeld a while back. I only recently connected it with my earlier mumblings about software layering, and here’s what came out. If a technology stack is arranged in such a way that there are consumers of value on one end of the stack … Continue reading “The protocol force”
At its core, the process of layering resolves two counterposed forces. Both originate from the need for predictability in behavior. One from below, where the means are concrete, but the aims are abstract – and one from above, where the aims are concrete, but the means are abstract. Each layer is a translation of an … Continue reading “AI Baklava”
I recently had a really fun conversation with a colleague about “declarative vs. imperative” programming paradigms, and here’s a somewhat rambling riff that I captured here as a result. When we make a distinction between “declarative” and “imperative” programming, we usually want to emphasize a certain kind of separation between the “what” and the “how”. … Continue reading “Declarative vs. imperative”
I have been thinking lately about a framing that would help clarify where to invest one’s energy while exploring a problem space. I realized that my previous writing about layering might come in handy. This framing might not work for problem spaces that aren’t easily viewed in terms of interactions between layers. However, if the … Continue reading “Asymptotes and Value Niches”
Riffing on the idea of layer gaps, we can surmise that pretty much every layer we ever get to write code for has gaps. If that’s the case, then anticipating layer gaps in our future can lead to different ways to build teams. A key insight from the previous essay is that when we work … Continue reading “Deep Stack Engineer”
My friend Dion asked me to write this down. It’s a neat little pattern that I just recently uncovered, and it’s been delighting me for the last couple of days. I named it “porcelains”, partially as an homage to spiritually similar git porcelains, partially because I just love the darned word. Porcelains! ✨ So sparkly. … Continue reading “Porcelains”
This one is a very short framing, but hopefully, it’s still useful. Whenever we operate in environments that look like pace layers (and when don’t they?), there emerges a question of relative velocity. How fast am I moving relative to the pace layer where I want to play? If the environment that surrounds us is … Continue reading “The waterline”