Menu‣
How to solve problems Solving Aging
Fiction The Hike
Other Projects Arcadia DEEPWAVE
You can comment on everything. Or give me (harsh) personal feedback.
Made with đź’™ by me (how to).
Dedicated to my family.
Status: More an inkling of an idea
After I’ve casually written down “Biology is Simple” in another post, and studying “Simplicity made Simple” by Rick Hickey (highly recommended), I actually think the claim “Life favors Complexity” might be inaccurate.
While thinking about how to not just write code, but actually take programming seriously, I’ve been asking: What is the optimal shape of not just the outcome of a program (Clean Code), but the optimal shape of the Input (way of thinking / building), translation (Code) and Outcome (Design, UX). As all three are deeply entangled and trade off against each other, specializing in any too early / deeply seems a mistake, leading to Scrum Masters, LISP and Product Managers respectively. So I’ve been looking at what they have in common: the tradeoff between simplicity vs. capability.
But the more I think about it the more it seems to be a deeper pattern. I claim that intelligence - and ultimately the fate of the universe - is what I once could call recomplecting; making things simpler.
I’ve always believed intelligence is compression, because the best possible understanding means being able to rebuild it with the fewest parts (decompression). If you understand a rocket, you can build it. And the less parts you need, the better you understand it. I know think that that’s only part of intelligence: it’s also about building better rockets. But first, let’s look at these partly made up word roots:
- Complexity: from “com” (together) and “plex” (fold, braided); the entanglement of things
- Complecting: to entwine, interleave, causes complexity
- Compression: from together and pressure, reduce size
- Decompression: building up something from a compressed version of itself
- Understanding: under, stand; seeing the ground / foundation, thing that holds it all together
- Explain: ex (outside), plain (flat), to make something you understand (inplain) understandable to the outside. Given your compression (understanding) and another persons decompressor, what is the minimum viable information they would need to get the same outcome?
- Essence: the understanding / most compressed version of a thing, the information that if only slightly varied, changes the most, also called crux, core, universal explanation.
- Decomplecting: unbraiding, turning something complex into a simpler version
- Recomplecting: finding a simpler arrangement for a complex thing, that keeps the essence of the whole, but changes their interactions of the parts.
It seems that compression and decomplecting are highly related: if you decomplect a thing, you might not be able to restore it to it’s original mess, but you can restore certainly restore it to some other mess. The question then becomes what disentaglement causes the loss of something that matters vs not: untying a goardian knot surely looses nothing, untangling a woven carpet destroys everything.
The complexity of life
Now, the most complex (intertwined) thing we encounter is life itself. Nature is a wild web of things all relying on each other, and human civilization has only added to that (not substraced).
But is that true? Is the future of the universe a story of greater and greater complexity? Are we going from simple planets that are easy to model, to interstellar civilizations?
This is not as entirely obvious to me. First it seems true that the universe will become less predictable with more intelligence in there. Predicting the next 1000 years of our solar system is exclusively and entirely dependent on what we humans do, even for extremely abstract measures like mass and energy balance. This is insane, but shows the power of “life” or “agency” or whatever you call it as - I think - a literal physical force. But complexity and predictability are not as obviously connected as I previously thought.
The main observation that is leading me to rethink all this is the one that complex things are less resilient than simple things. If you can make a thing in 2 steps instead of 3, life will find a way to do it in 2. But more importantly, if you can do it with less intertwining and better abstractions, life will also favor that.
Let’s take the example of a virus and a cell. Which one is more complex? Well, on first sight it’s the cell. It’s big, has many compartments, many functions. The virus is just a strand of nucleotides and a shell. And just look at the reproduction strategy: the virus just needs to find a fitting cell, and can use all the existing machinery. The cell has to rebuild each and every component, if it wants to duplicate itself. Even more complex seems the modern human which has to go through thousands of steps to make a single baby.
But there is a problem with this picture. The question is: complexity of what? What is intertwined?
I suggest to look at internal vs. external complexity: Humans are more complex than cells or viruses, if you look at them under the microscope. But look at them in the grand scheme of things: only humans will be able to go to the stars, build O’Neal cells, travel the galaxy. Yes, bacteria can survive the very cold and might start life on a distant world, but only if the rare chance flings them there. Viruses certainly won’t. Humans can go where no statistic can, close to the sun, into the depths of icy moons, etc. The difference is that we have low external complexity, we’re less intertwined with the rest of the universe. In some sense, viruses are the most complex of the three: they have to find a very specific cell it can breach, capture and reproduce in. The cell just gobbles up some resources, and then divides. Humans can think up an idea (a part of themselves) and spread it over the internet with the push of a button.
Especially given the last sentence, you might reject that this is simple and just hiding the complexity: for me to write this text so many intertwined things had to interact, from my cells and microbiome to my brain, to the internet server that causes you to read this. All these depend on each other, in a way that’s hard to ignore, so sending a meme is clearly way more complex than a virus. But again, complexity of what? Infastructure or message?
Maybe let’s define the word simple: it seems to be related to complex, and indeed, it comes from simplex, “one” (think single) “fold”. So if a complex thing is highly intertwined, a simple thing can stand alone. Pushing a button is simple. Breathing is simple. Solving 2 + 2 = 4 is simple. Doing a handstand is simple (not necessarily easy!). Simple is doing something, without having to keep track of another thing. Doing all those things together is complex (but notice how some combinations are simpler than others: breathing while doing math, simple; doing a handstand while pushing a button? Why?).
Again, one could argue breathing isn’t simple at all, it’s a very complex queue of physical movements, and an even more complex set of chemical reactions. I hope to convince you that it’s not, but instead it uses abstraction, fungibility, agency and emergence to actually be simple.
First of all, what is life, design or really anything trying to do? It’s trying to optimize between resilience and capability: do as much as you can, without breaking. Survive longer, in more niches. Reproduce faster than the competition, without using up all the resources (this second part is wrongly ignored by some evolutionary models: if you run any evolutionary process long long enough you will mostly observe environment shapers, not pure “grabby” aliens, but I digress).
So how best to achieve this? Well, capability clearly seems achievable by more complexity. We all know that one app that just adds feature after feature, and we can all predict how the source code of that looks. Complex. This makes sense: combining two things often leads to behavior that’s greater than the sum of its part. Just imagine cooking, but none of the ingredients would mix.
But adding things gives you unintended consequences, bugs and unpredictability. Even worse, it gives you dependance: a butterfly that can only survive if a certain flower blooms during a certain phase of the moon might be beautiful, but it’s also very fragile. To achieve resilience, you have to be simple. Simplicity guarantees flexibility and independence.
So how do you solve this seeming contradiction? Is this just like any other tradeoff and we observe life to be as complex as it can get away with? Not really, because there is an elegant solution: hierarchical agency. If the queen ant can say “get me food” (a simple act) instead of having to worry about how, the cababilty stays the same (she can still survive in the exact same environments), but things have become less complex, not more. This is counter intuitive: at first there is a new dependency, the lives of ants are now intertwined. One can never understand a single ant. But from the perspective of all ants, life has become simpler: the worker just worries about food, the queen about laying eggs. The behavior of the other is abstracted (from “moved away”), the life of the individual becomes fungible (exchangable, the behavior of each ant does not matter, just the quantity). I don’t know if there are formal models of this, but taking 10 complex things and introducing one meta-thing that adds complexity, but removes it from all the parts, seems to me like reducing complexity in total.
Important note: this does not mean that the hierarchy is “real”, in the sense of top-down control. Ants are actually a good example: the queen does not really “command” anything like we would think given the name. It’s just an egg-laying machine, highly controlled by the workers. I use the word hierarchy more to describe the relationship between cells, ants, and the emergence of this thing called an “ant colony”, which can now itself have simple or complex relationships with other ant colonies. In this sense “emergence” isn’t actually this magical, non-physical word: if combined right, things can be more than the sum of their parts, exactly because they make things simpler.
Another way of looking at this is through graphs: In small teams or early companies drawing an org chart is often futile: everyone does a lot of things, connected to each other. All members are intertwined, the relationship graph a mess. As companies grow, they start to form clusters of teams and build informal interfaces: “that IT guy, the person to talk to about sales”. Eventually these crystalize into stricter hierarchies with middle management. This is often criticised and seen as bad (mainly because companies build leaky abstractions: the PM does not get the right information from customer support briefings, nor understands the problems of coders, so isn’t actually a good interface), but - because it is simpler - it does last longer and therefore usually grows larger. (This leads to an interesting prediction about what companies should survive in capitalism: ones that have better internal abstractions).
This notion - that life reduces complexity, by turning dependency graphs from flat to hierarchical - is still counterintuitive to myself, but it seems “big if true” and I’d love to hear your toughts. It would means that the UX trend of simpler and simpler interfaces (Terminal to search bar to chatbox) is not just nice, but hinting at a law of nature.
Simple ≠Easy
Note: this does not entail that solving biological problems is easy. To take Rick Hickeys analogy again: easy comes from “close at hand”, so the opposite of easy should not be hard, but distant or unfamiliar. An example: washing hands is a simple solution (killing 99% of bacteria can be done with one action: breaking their membrane), but getting to that insight took a long time. This might be because evolution cannot just use open simple interfaces - if ants would listen to any command telling them to get food, they could be very easily exploited. So evolution uses obfuscation, think https vs http. But just because something looks complex und cryptic does not mean the underlying message is complex. A good example might be the immune system and how it detects if a cell belongs to us or not: we cannot yet recreate that message, most organs get rejected at one point, but underneath it’s just a simple handshake, an equality operator over an auth token.
P.s: I suspect something similar is going on with aging - there is a parasite that can infect ants and make them live 20 years longer - but this does not mean we will solve it soon.
Footnote 1 (caveat: it’s often unclear if something is an implementation detail vs. a pattern: do you need to be able to write C in order to program the board computer of a rocket? Or can you argue that that’s not important, because any language would work? But thats not entirely true because radiation resistent hardware is always limited, so you will need to know a memory-optimal language, not Python. It becomes blurry quickly).