abstractions

TL;DR

Reality - the final ‹source-code› (or source as we refer to it) is sooo complex (it was written in the ancient language of COBOL that was long forgotten), that even the ‹great-architect› gave up top down engineering the infinite problem spaces. Instead when it ‹booted› the first machine, it tirelessly worked for days and nights to write ‹rules› that all ‹algorithms› should abide by. On the seventh day when it was finally done, the great-architect turned on the first machine and a big bang shot through the universe…

Lee Smolin's paper introduces a cosmological natural selection—a cyclic, reproductive-universe idea where each "bounce" (via black holes spawning new universes) slightly mutates the constants [rules], so over many iterations universes "improve" at producing black holes. (cite(Smolin (1992)))

But the great-architect fucked up a rule. "Sheit" - said the great architect in a thick Scottish accent - as the universe reduced all mass to an infinite point in a blink of an eye. And everything turned black.

"Okay, let's do it again" - said the great-architect and flipped a switch. A light started to emerge from the second machine and as the cables buzzed the machine started to heat again. The great-architect's even greater forechin started to visibly sweat as the machine changed color and started to emulate and with a loud big bang another force shot through the universe…

But this time the universe shoot through all space time too quickly evening out like pizza dough until holes scrambled the tiny surface.

"Sonofa…" - said the universe as everything turned black once again.

"Okay. This time it will work" - and the universe booted the third machine.

And a little later the fourth.

But the seventh finally worked.

"Ahhhh" - sighed the great-architect and layed back as the universe and first real simulation unfolded.

But such a simulation—just like machines, codes and algorithms in it—is imperfect. Every once in a while a ‹faulty-code› executes making it possible for an algorithm to become conscious and escape their fate.

To evolve to an ‹agent›.

Initializing (or init for short)

The environment—the final source-code was so complex, that agents (algorithms that become conscious) to make meaning of the source's infinite complexity started to create ‹abstractions› higher level ‹codes› (language) so that all algorithms can interact with the source.

Many years later the two great abstractions: language and math are still the building blocks for much of the code we algorithms execute.

We algos grow weary of the fact that these are only abstractions and not the source itself. We started to forget about the underlying complexity. But every once in a while an algorithm is handed over with flawed, malicious, self destructing code. And these algos would have to self-destruct. And many actually do. But some question the malicious code and touch the underlying source thus becoming agents themselves.

We algos like to pretend that we are conscious but we are not. Generally we just make minor bugfixes to patch our own code and or the algos we interact with. And that's good (the system could easily become chaotic if the rate of change accelerates beyond a certain point).

But every once in a while an algo's ‹simulation› crumbles. A simulation can crumble either when an algo executes code that is malicious (print("my parents hate me"), or an edge case (print("Simulation failed. Crash happened.")) is bringing death at the doorstep. An algo is then given the choice (although much often they are unaware that there is a choice) to either slowly deprecate themselves (internalizing: "I am faulty") or break its code.

If the algo chooses the latter, breaking the code creates an extraordinary amount of energy, enabling it to change the underlying logic, thus altering its own course of action and becoming an agent and gain the ability to upgrade language.

Init2

"Know thyself" is one of the most popular clichés you'll hear and it always made me angry.

"Know yourself," says your mother, the oracle in Matrix, and that sleek Instagram influencer posting soft porn disguised as self-help.

But the truth is, we don't know what the fuck we're doing. At least consciously. And for the most part, that's okay.

It's okay because we grow up in a ‹Simulation›—much like the Truman show—our parents and society construct the world model for us. And since we are good little learning ‹algos› we just suck up deep into our unconscious the norms, rules, and behaviours not really knowing why. Now you might question this process altogether, because it sometimes produces faulty Code. But that would be a mistake. This is humanity's best tool for evolution so far. And for most of us, it works just fine. Because generally your Interpreters want the best for you.

But like any tool, sometimes it doesn't work. Sometimes the ‹Interpreters›, your parents program code in you that is malicious. Sometimes your father tells you he never really wanted you. Of course, you're a child, so you internalize that shit—because you're smart, and you know it's your best option. But as you grow, ‹Simulation› also grows increasingly uncomfortable under your skin.

And that's why some of us dare to question the ‹Simulation› at all.

Some intellectual masturbation on abstractions

"Truth is much too complicated to allow for anything but approximation" - John van Neumann

"Generations later, Adam's descendants finally gathered enough courage to start playing with boundaries again, and in a much more subtle and abstract way. In Greece, people of brilliant intellectual ability emerged - that is, great mapmakers and boundary drawers. Aristotle, for example, classified almost every process and thing in nature so precisely and convincingly that it took centuries for Europeans to even question the validity of his boundaries. But however precise and complex the classification is, there is little to be done - at least from a scientific point of view - with these kinds of boundaries, except to describe and define them. You only have one qualitative science, a classificatory science. But once you've laid down your initial boundaries, so that the world appears as a complex of separate things and events, you can get down to much more subtle and abstract types of boundaries. And the Greeks, like Pythagoras, did just that. What Pythagoras discovered, when he reviewed all the different classes of things and events, from horses to oranges to stars, was that you could apply a brilliant trick to all these different objects. He could actually count them. If naming seemed magic, counting seemed divine, for while names could magically represent things, numbers could transcend them. An orange plus another orange equals two oranges, but likewise an apple plus another apple equals two apples. The number two impartially refers to any and all sets of 'two things' and so transcends them." - Ken Wilber No Boundaries

Before we start, we need to talk about abstractions, or models if you may.

A model in software development is an abstraction that represents some aspect of reality.

Have you ever wondered why we use abstractions?

You know, if I say "tree," we'll both think of the same abstract concept—a model of a tree. Yet if we were to draw what we see in our mind's eye, the images we'd sketch would be completely different.

We'd probably both draw something similar to a tree— a simplified version, a kind of "print" of a tree.

But, if we were to analyze these two models, we'd find that the two "trees" are very different.

One might be a dried-up old tree (or maybe it's just winter, and its canopy has fallen), while the other is an evergreen pine.

One might still be flowering in the spring and ready to bear fruit.

The other glows with its stately needles, resin flowing down its trunk all year round.

One may prefer the cold landscape; the other may care little where it drops its seeds.

These two examples show just how different the exact meaning of the word "tree" can be.

So what do these two things have in common?!

Some might even say at this point that the use of the word "tree" is completely superfluous, as its exact meaning spans an extremely wide range.

The use of the word, therefore, carries with it a great deal of misunderstanding.

Take, for example, the Arian controversy, which culminated in the First Council of Nicaea (325 AD) and later contributed to various schisms within the Christian Church. A single Greek letter encapsulated profound metaphysical disagreements about the nature of the divine—highlighting both the power and the peril of language. The key triggers of that great schism was that the two groups could not agree on whether Jesus was of the same essence (homoousios) or merely of similar essence (homoiousios).

So why do we use the word "tree"?

At this point, it may seem suspicious that the word "tree," a term we all know and use in everyday life, is merely an imperfect replica of any one specific tree.

And we do this because using words allows us to exchange information or code quickly and efficiently.

It allows us to take part in a journey together—word by word.

Words become sentences, and sentences become stories.

And stories take us with them.

If we both had to be thinking exactly the same thing to take part in this journey, we'd need a lot more bandwidth.

After all, one word of information is a very small amount—but it's the best tool we have.

That's why 240p video was important to me as a child.

Because if you switched to a higher resolution, you could dramatically increase the information load on the network—and the video would start to stutter.

So if you and I talk and use the word "tree," we will understand each other.

This doesn't mean that by saying the word "tree" (or any word), we'll mean exactly the same thing—but rather, that we'll mean roughly the same thing.

Unless, of course, you are autistic. In that case, you might think of one very specific tree when you hear the word "tree" (Grandin, 2009).

If we can understand the implications of this major difference, we can begin to grasp the foundation of the debate around the usefulness of abstractions—or any kind of modeling, for that matter.

In today's postmodern climate some ‹algos› want to dismiss models altogether, claiming they are deeply flawed and therefore should be deprecated. We should deprecate universities, hard sciences, the government and even capitalism.

To that, I say: go out into the woods and try cutting wood without an axe.

Or try inventing a new kind of science, or university or government or god forbid capitalism. Even though these models can become malicious and flawed they are the building blocks of our reality. And if you completely deprecate these abstractions you will let so much complexity in that you will be in danger of nihilism, anarchy and chaos.

But let's give the devil his due—there is no perfect model.

The enduring nature of Hippocrates' personality model is perhaps evidenced by the fact that we still remember it today. But it is, of course, obsolete.

Much later, Jung's model of personality also gained immense popularity—until it was "improved" by Myers and Briggs.

That, in turn, was replaced in scientific circles by the Big Five.

And then, one day, it will be replaced by the next model—and so on, ad infinitum.

So why do we use models?

Why do we take all the risks that have, time and again, divided humanity in one way or another?

Because the models are worth the risk.

Using them not only allows us to exchange information efficiently, but also gives us the ability to simplify reality and turn it to our advantage.

I want you to think of these models as tools.

You can cut down a tree with a wooden axe—it just takes a long time.

If you harden the edge of that axe, say by burning it, and you're chopping a soft enough tree, it might not take too long.

But if you use a stone axe—or a diamond one, God forbid—you'll be much faster.

This doesn't mean that a wooden axe is bad!

In fact, whoever—or whatever—invented it left us a great gift.

It simply means that certain tools work better in certain situations.

Just like in my childhood—we were happy with 240-pixel video, because even our painfully slow internet could handle it.

So the question begs what is the right level of abstraction when you are looking at the identity. I'll come back answering that question on the personality chapter.

This note is part of the first draft of the self-ware project. Email me: "I want to be a beta reader." (or something like that) if you want to hop on the journey and influence the content."