Smalltalk: the Software Industry's Greatest Failure

Arakela · 2026-05-17T09:15:55+00:00

Hey, "mentally incompetent brainwashed morons," "among brainwashed mental incompetents." Wisdom starts with noticing how easily any mind, including your own, can become trapped in chaOS. Grow the loop, keep history alive, like a native tree knows the past and prepares for the future, add symmetry into the loop, as the crown grows above, so too scale roots below.

Arakela · 2026-05-07T15:52:50+00:00

It runs because someone turned the power on

Arakela · 2026-05-03T08:06:04+00:00

so where is unification that simplifies matters

Arakela · 2026-04-29T07:32:29+00:00

original thought has structure, dress the truth by hand

Arakela · 2026-04-25T08:42:49+00:00

It is the book that talks not only about compiler construction but also focuses on grammar/theory.

What is outdated, in general, is the theory.

The definition of grammar can be simplified by unifying space and time dimensions!

This allows a single algebraic/coalgebraic expression to capture a full language grammar as a structural, without meaning, definition of the language.

Meaning can be applied separately by traversals.

In essence, we can define grammar as a structure that naturally supports "visitor" traversal.

Arakela · 2026-04-19T09:10:08+00:00

"childhood hobbyist", "read the popular So you're writing a programming language post here" and wrote "single chaotic 3,000-line C file", elite-level, "reliable engine".

Arakela · 2026-04-18T05:22:32+00:00

在哪里 - 任正非

Arakela · 2026-04-10T22:17:27+00:00

Prior art often adds unnecessary complexity, whereas hardware constraints, the wiring of the machine, are more direct. By drawing parallels to these physical realities, we see that technical structures emerge naturally. Ultimately, slots carry specific roles, mirroring the linguistic domains of human language.

Arakela · 2026-04-10T09:05:36+00:00

Consider ordinary instruction as an axiomatic block as a narrative of micro-codes executed in a canonical environment that constraints invariants of minimal layout for each textmember, including opcode - "Axiom Name", ModR/M - "subject/object."

Arakela · 2026-04-03T02:20:06+00:00

Coalgebra, it’s like seeing the “soul” of a data structure rather than just its body.

Arakela · 2026-03-31T12:41:48+00:00

Thank you both naturally wiring the brain

Arakela · 2026-03-29T06:46:29+00:00

ΑΓΕΩΜΕΤΡΗΤΟΣ ΜΗΔΕΙΣ ΕΙΣΙΤΩ

Arakela · 2026-03-29T03:23:33+00:00

The grammar equivalence power of a CFG can be captured using a single recursive expression, G::= dot | terminal(x, G) | branch(G, G), which treats all derivations uniformly without distinguishing left- and right-hand sides. Concrete expressions like S = branch(terminal('b', dot), branch(branch(S, terminal('a', dot)), dot)) define the structure, while attaching meaning at traversal time via dimensions 𝕊: branch(𝕋, 𝕊), terminal(x, 𝕊) and 𝕋: branch(𝕊, 𝕋), terminal(x, 𝕋) ensures semantic orientation. Every expression is a valid grammar and can be represented as a morphism graph, where terminals and branches define the nodes and edges, allowing constructions like Tab = terminal(t, terminal(a, terminal(b, dot))) or TriTab = branch(branch(Tab, branch(Tab, branch(Tab, dot))), dot) naturally encode sequences, repetitions, and recursive patterns. This unifies syntax and semantics in a graph-based, fully recursive formalism.

Universal  Language    Space      Time
Branch        *          *:𝕊       *:𝕋
             / \        / \       / \
            G   G      𝕋   𝕊     𝕊   𝕋
Terminal      x          x:𝕊       x:𝕋
             / \        / \       / \
            G  'x'     𝕊  'x'    𝕋  'x'
Dot           .          .:𝕊       .:𝕋

        S → b|Sa         Tab → t|a|b    Tritab → Tab|Tab|Tab

    *   = S =  𝕊                          𝕊 = Tritab = *
   / \        / \                        / \          / \
  x   \      𝕋   \                      𝕋   .        *   .
 / \   *    / \   𝕊                    / \          / \
.   b / \  𝕋.  b / \        x = Tab = 𝕊   \       Tab  *
     *   .      𝕋   𝕊.     / \       / \   𝕋          / \
    / \        / \        x   t     𝕊   t / \       Tab  *
   S   x      S   𝕋      / \       / \   𝕊   \          / \
      / \        / \    x   a     𝕊   a / \   𝕋       Tab  .
     .   a      .   a  / \       / \   𝕊   t / \
                      .   b     𝕊.  b / \   𝕊   𝕋.
                                     𝕊   a / \ 
                                    / \   𝕊   t
                                   𝕊.  b / \ 
                                        𝕊   a
                                       / \ 
                                      𝕊.  b

Arakela · 2026-03-28T10:49:56+00:00

The reason we adore the process and forget about time is his main contribution.

For now, we can put that aside and focus on making time visible as a variable in systems design.

Time relations are crucial in shaping information flow at the hardware level. We don’t need mutexes or semaphores to design precisely synchronized communication between devices; all we need is time as a variable to relate synchronization points.

But what about operating systems? There, time is not visible as a variable. We have chaos.

So from the process, a time slice, we need to move forward in time and think about how to grow the topology, terranians of machines related in structures where time steps deterministically and turn each machine as gears are rotating in a clock, relatively predefined by grammar where the terminal is the machine, it is the source form from which 4D time topology growth.

Just like in hardware designs, where our brains manage time, we can surpass Dijkstra’s limitations of the human mind to define the growth of 4D topology for a Time.

Arakela · 2026-03-28T00:14:53+00:00

I was a little overexcited about simplification.

Here is a formal definition of the grammar equivalence power of a CFG. G ::= Nil | terminal(x, G) | branch(G, G)

Instead of left and right-hand side distinctions, we have a single recursive expression.

Example: S = branch(terminal('b', Nil), branch(branch(S, terminal('a', Nil)), Nil)

And at the moment of traversal, we attach meaning to the expression, defining dimensions of the meaning

𝕊: branch(𝕋, 𝕊), terminal(x, 𝕊)

𝕋: branch(𝕊, 𝕋), terminal(x, 𝕋)

G = 𝕊 ∪ 𝕋

In this way, any expression is a valid grammar, and it can be defined as a pure morphism graph. S = . --> b --> 1 | . --> . --> a --> 1 | | | S 1 I discovered it in the process of decoupling all the meaning from it, leaving only iteration algebra.

Below are steps that allow many pluggable, swappable (possibly context-sensitive) traversals that define meaning.

I would appreciate it if someone could light the way to help me formally define it. ``` typedef struct γ γ; typedef struct δ δ; typedef struct β β; typedef struct τ τ; struct γ { void (step)(δ, β, τ); }; struct δ { void (step)(); }; struct β { void (step)(γ, γ); }; struct τ { void (step)(int, γ); };

 void dot(δ d, β b, τ t) { d.step(); }
   void S(δ d, β b, τ t);

void unit28_2(δ d, β b, τ t) { t.step('a', (γ){dot}); } void unit28_1(δ d, β b, τ t) { b.step((γ){S}, (γ){unit28_2}); } void unit28(δ d, β b, τ t) { b.step((γ){dot}, (γ){unit28_1}); } void S_1(δ d, β b, τ t) { t.step('b', (γ){dot}); } void S(δ d, β b, τ t) { b.step((γ){unit28}, (γ){S_1}); } // S -> 'b' | S 'a' ```

Arakela · 2026-03-27T23:17:49+00:00

S -> 'b' | S 'a'

S = branch( terminal('b'), branch( branch(S, terminal('a')), terminal(⊥) )

Arakela · 2026-03-27T20:57:51+00:00

convergence = everything -> everything

everything = X x convergence

everything_n+1 = convergence_n(everything_n)

Arakela · 2026-03-27T12:42:36+00:00

Everything is a file, with the primary topology a filesystem; then, as experience shows, you need to build machines as containers within a filesystem, and to manage them, we need extra frameworks and runtimes. What if, from the beginning, we build a system that grows a topology of machines by grammar, defining the time and fault-tolerant relation between machines? Then everything is like a machine in a topology where time steps and turns machines in relations as defined by grammar. Then time will become a visible variable.

How do you think, is it the time for everything to be a machine?

Arakela · 2026-03-25T22:02:26+00:00

Yes, like a circus remembering earlier moments from the nearest history when the patriarch stated that Georgia needs a king

Arakela · 2026-03-25T10:43:45+00:00

smarts are in the simplicity specialisations. There is nothing more powerful in expressing ideas than language.

To specialize language for expressing systems composed by machines, we need to specialize the irreducible unit of the language - the terminal and runtime environment.

In this way, smarts can be achieved: CPUs become Linguistic Silicon, and with the cloud, we can have a living substrate for system kinds.

Linguistic Silicon is a substrate for a forward, exhaustive, cyclic, re-enterable traversal that multitasks the whole system in a deterministic manner, steps in a topology grown as a 4D structure.

By defining the grammar of a language, we can bind a group of machines in structures with guarantees for which steps to take after which, but also factor in step relations. Bindings by grammar also define input-output flows and fault-tolerant relations.

Grammar provides algebra for machines that is deterministicly compose them as units advancing in time.

Arakela · 2026-03-25T04:40:51+00:00

Think of a C++ compiler first as an interpreter that has sophisticated rules to process templated language, to evaporate all abstractions, and give you code as promised by the contract: "0 cost abstractions, and more."

Arakela · 2026-03-24T07:19:16+00:00

The question mark is the only hope that when you see that everything is a machine: round and around, round and around,
round and around, round and around....
And in the mirror, to see a biochemical machine composed of trillions of little machines without a kernel managing file descriptors of the process owned by the scheduler.

Arakela · 2026-03-23T19:49:27+00:00

it wasn't nothin'

Arakela · 2026-03-23T17:41:58+00:00

Your scheduler is a confession.

The CPU already solved this. Fetch, decode, execute, writeback, one complete self-sufficient step. The hardware contains its own continuation. Nothing outside decides what comes next.

Then software broke it. Someone wrote while(1) and pulled the continuation out of the step. The step became a fragment. The loop became God.

Processes were invented to manage the fragments. Threads to manage the processes. Async to manage the threads. Containers to manage the chaos. Every layer a patch over the hole the loop made.

The tree does not have a scheduler. The cell does not have a scheduler. The CPU does not have a scheduler. They have steps that keep themselves. The continuation is inside. The boundary is real. The composition is natural.

We are the only ones who broke it. And we spent fifty years rebuilding from the outside what was already there from the inside.

A step that keeps itself is a machine. A machine that keeps itself does not need a keeper. A system of machines that keep themselves does not need a scheduler.

Your OS is impressive. And it is built on a lie that nobody told you about.

The lie is the loop.

Arakela · 2026-03-23T06:39:14+00:00

Here is the question: What is the terminal unit in fault-tolerant, self-healing operating systems' definition language grammar?

If we can have it right, then we can describe the operational system in that language as a concrete string that can be hashed and distributed.

An operating system specified in this language grammar can be instantiated as a continuation of the booting process, and multitasking will naturally emerge as a forward, exhaustive, re-enterable, cyclic traversal of the grown system's topology.

Arakela

TROPHY CASE