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”
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”
Preference toward layering is probably one of the more fundamental principles of software development. It pops up pretty quickly as soon as we start writing code. I wrote about layering extensively in the past, but basically, when we start connecting bits of code together, a tension arises between the bits. Some need to change faster … Continue reading “The Layering Principle”
This principle builds on the layering principle, and deals with a common decision point that most software developers reach many times in the course of their work. The situation that leads to this point unfolds something like this. There is some code at the lower layer that isn’t giving us the results we need for … Continue reading “The Wallpapering Principle”
Riffing on the cost of opinion piece, I realized that there’s a neat framing around opinion mutability and the underlying systems dynamic that’s worth mentioning. One way to think about the settledness of opinion is as finding a reasonable balancing point between the value and cost of the layer, where the value compounds at a … Continue reading “Moving the ladder”
I have been reading Alex Komoroske’s Compendium cards on platforms, and there’s just so much generative thinking in there. There’s one concept that I kept having difficulty articulating for a while, and here’s my Nth attempt at defining it. It’s about the thinness and thickness of layers. Given that layers have vectors of intentions, we … Continue reading “Cheesecake and Baklava”
It appears that I’ve been writing this essay since 2012, never quite finding the right framing. One of my brilliant colleagues asked me this question back then: “How do you evaluate whether a Javascript framework is good for the Web? You seem to do it intuitively, but I don’t get it. What’s the logic?” And … Continue reading “The cost of opinion”
I’ve been thinking about the different conditions under which innovation emerges, and how the environment influences the kind of innovation that happens. To set the stage, I am going to do a very brief detour into biology (I am not a biologist, so will definitely make a mess of it) and use the r/K-selection lens … Continue reading “r/K selection and innovation”
With my apologies for taking a scenic route and sincere thanks for following along, I am happy to declare that we now have all the parts to return to that framework I started with. To give you a quick recap, the framework was my replacement for Cynefin and consisted of three problem classes: solved, solvable, … Continue reading “The problem understanding framework”
I had a super-insightful conversation this week with a colleague about approaches to resolving pace layering confusion. For those of you who haven’t heard of it, Steward Brand’s concept of pace layers is something I’ve often applied to layering in software engineering: the lower the layer, the more stable it is. The higher the layer, … Continue reading “Forces of the pace layering confusion”
