Esoteric teachings

There are fundamentally two modes of searching or exploring – breadth-first and depth-first, along with some heuristics and attempts limits the depth and backtrack before it is too late.

Depth-first is when you know just one language, lets say PHP or Java and become an expert by doing. This is what John Carmack did with the C/C++.

Breadth-first is when one is trying not to miss anything and to explore systematically everything what is out there. This slow, difficult (takes a lot of your precious resources), and you may run out of time or of your mental capacity (which begins to decline sharply in your 40s).

Breadth-first search is optimal but seems like unrealistic.

One may explore, deliberately not going deep into random rabbit holes, like The Number Theory, The Category Theory, backtrack from Albelian Groups and so on, only to develop this notion that there is some locus, which consists of different views on one single “What Is”.

Then suddenly, when one places What Is, and the notion of an external observer (the Mind) at the center everything falls into its places and “clicks”. You suddenly know what mathematics and logic are and why they are the way they are (this is because they are products of the Mind).

With little more effort one discovers, reading THE ARCHITECTURE OF COMPLEXITY, by HERBERT A. SIMON, that there are “patterns” in molecular biology and complex systems in general. If you ask why you will understand the basis (what we call Evolution is billions of continuous individual processes of trial-and-error).

Then, perhaps, the Let It Crash mantra of Joe Armstrong, the great, will suddenly make a lot of sense (crashing early and restarting is operationally the same as a quick backtracking from a dead-end and exploiting another branch), as well as insistence of using the pure user-facing language (mostly-functional).

When we went deep-enough, hopefully not missing anything significant (of which one cannot be ever sure) it is time to stop and begin to “unwind the recursion”, generalizing from what we already know and pruning out (discarding) what is irrelevant and redundant. Descartes did this.

It turns out that there are just 3 strucutural patterns in the charts of algorithms, only 3 rules in the Lambda Calculus, and only 3 things one can do with any two values

• ,
• |
• ->

and the logical conjunction, disjunction and implication are suddenly fell into its places.

A lot of people have discovered this “locus” independently, like observing the same mountain from different sides. People call it the Curry-Howard Isomorphism but it is not the name that is important, not even the isomorphism itself, but WHY it is the way it is.

These are the only required buildings blocks for BNF grammars and corresponding Finite State Machines (FSMs). So, an abstract “language-machines” are very closely related (how else could that be if both mathematics and logic are languages).

Everything can be reduced to the just a few fundamental notions a Mind observing What Is (and distorting its inner representations with abstract bullshit). This is what is behind that Curry-Howard isomorphism.

Notice that -> at a type-level stands for composition, and has a fundamental property of nested calls being indistinguishable from a single “arrow”.

“Arrows” as a directed transition and a single step (transformation) are so fundamental that we usually do not even pay attention, but any process can be defined in terms of arrows between dots.

When one begins to “unwind the recursion” (metaphorically speaking) one dismantles whole Himalayas of bullshit.

A Prime number is a number such that no repeated addition of any number to itself can produce it. There is nothing more to it. Surprise? There will be more.

Ever heard of forks and joins. Joins are “real”, forks – “imaginary”. Joins corresponds to “multiple causes” and forks to an “illusion of a choice” (“potential” paths are hypothetical).

What are the graphs with no forks then, and only with joins? Well, the paths Evolution was taken looks like this. The execution paths of running code too.

A few things we are conditioned to “know” are not what they seem (The Owls are not what they seem).

What about time-sharing? Well, there is no notion of time in molecular biology and this is why and how it is “stable” (has stable building blocks). There is no Mind to superimpose a coordinate system and count the notches at that level.

Neither it should be within the running code.

Molecular biology does not have the notion of an external observer, so mother nature does not count. It uses structural pattern-matching, asynchronous structured message-passing and signalling instead.

There is more. A lot more. Evolution has been discovering the fundamental stable building blocks for us.

Everything has its structure, but there are just 3 fundamental ones - a sequence, a tree, and a lookup table.

Linear sequences are the most fundamental, but they are not enough. Once we go beyond linearity and creating simple tree-like structures out of processes we discover another universal pattern, which is literally everywhere.

A hierarchy is a biological pattern at a system level, so it should be fundamental in our systems too. Again, Erlang guys got it right and structured their processes in “supervision trees”.

They also incorporated asynchronous communications into the language, along with an event-driven IO (just like evetything happens in the real world).

So, just lists, threes and tables, not even graphs, because only simple, straightforward, dientangled system work.

What appears to be incomprehensibly complex is just repeated simple “patterns” within stable intermediate forms. Our software should, obviously, be designed this way, while systematically pruning and elimination redundant, suboptimal bullshit. Only Erlang did it so far.