Moving the ladder

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 relatively similar rate as costs. Opinions that find that point tend to be more settled, and opinions that are still looking for it are more transient.

Think of it as a spectrum. At one extreme are layers whose opinions have completely settled, and on the other – the layer where transient opinion churns like whitewater. As an example, the IP Protocol and the TCP/UDP twins that sit on top are a pretty good example of settled opinions. Even though I am sure there are people somewhere trying to invent something more awesome than these, I am going to rate their displacement  as “extremely unlikely.” 

On the other hand, the Web continues to experience the effervescence of Javascript frameworks that are born and discarded seemingly every month (week?), subject to fascinating natural selection-like dynamics. It would not at all be controversial for me to suggest that the opinion at this layer hasn’t settled yet.

Why do some opinions settle? And why do some continue to shift? Stewart Brand has this wonderful concept of pace layers that is pretty instructive. The idea behind pace layers is that all complex systems tend to organize themselves in terms of layers, and each outer layer evolves at a faster pace than the lower one. Stewart even attempts to introduce a taxonomy of layers, which I am not going to use here. However, this notion that inner layers shift at a slower pace than the outer is very useful in this conversation. I am not a biologist or an ethnographer, so I can’t speak for forests or civilizations. However, based on my experience in developer ecosystems, their layers are almost always organized in a pace-layer like fashion. It’s almost like the spectrum I was describing earlier is actually a description of the developer layer stack: things that are settled sit at the bottom (think TCP/IP), things that are frothing with change are at the top (think Javascript frameworks), while the layers between them span the gamut.

And I have a guess on why this happens. As a thought experiment, let’s imagine that our layer is like a ladder – I know, it’s analogy time. Just like the layer’s vector of intention, our ladder is currently leaning next to the upstairs bedroom window, where our uncle Steve just finished cleaning it. Good work, uncle Steve. Now, Steve wants to clean the bathroom window, which is a bit more to the left. The requirements changed and now, our vector of intention needs to adjust to point in a different direction. What do we do? Naively, we might say – let’s move the ladder! However, if we try to do that, we might hear some choice words from our uncle who suddenly finds himself hanging onto his dear life at the top of the ladder. Falling down is not fun. Instead, it is more common that Steve, the family daredevil that he is, chooses to lean out to reach the bathroom window. He might yet fall, but dammit, it will be on his terms. What our uncle just did there was layering. He’s okay, by the way, though Grams did see his stunt and will chew him out later. Uncle Steve created an extra layer on top of the ladder, and formed an opinion: an angle between the vector of intention of the ladder and that of his own. Even though the “rational” thing to do would have been to a) climb down the ladder, b) move it, c) climb it back up, he freakin’ chose to risk his life to save a bit of energy and time.

This move-the-ladder dynamic happens all the time in software layers. As a rule of thumb, upper layers prefer the lower layers to stay put. Waiting for the lower layer to adjust feels like giving up agency, so they tend not to. Instead, they expect the lower layer to remain roughly where it is now, perhaps refining some bits here and there, but not doing any wild swings toward the bathroom window. Recursing this effect through the layers, a pace layer structure develops. Every lower layer has more uncle-steves yelping and demanding they “whoa hold it there, you <redacted>”. Every change at a lower layer becomes a matter of painful negotiation that takes time and energy – and so the layers below tend to move at a much slower pace. It is fun to be the outermost layer, but as soon as anyone takes you as a dependency, the move-the-ladder dynamic starts to manifest itself. Every successful developer surface experiences it, and suffers through it.

Getting back to our notion of settled and transient opinions, I hope that uncles Stewart and Steve provided enough illustration of this idea that opinions of the outer layers tend to be more transient, and the deeper they go in the stack of layers, the more settled they become. It doesn’t make them right. Settled opinions could be patently, obviously wrong. However, given the full height of the ladders and foulmouthed uncles that tower above them, changing them involves a bucket of miracles.

One thought on “Moving the ladder”

Leave a Reply

%d