C. Guy Yarvin is a “good friend” of Mencius Moldbug, a
pseudonymous blogger known for iconoclastic novella-length essays on
politics and history (and occasionally computer science). Guy recently
published, under his own name, a project in language and
systems design. His own writing about his work is entertaining but verbose
(as Moldbug's readers might expect), so I will attempt to summarize it here.
Nock, Urbit, Watt
First there is Nock, “a tool for defining higher-level languages –
comparable to the lambda calculus, but meant as foundational system software
rather than foundational metamathematics.” Its primitives include positive
integers with equality and increment operators, cons cells with
car/cdr/cadr/etc., and a macro for convenient branching. Nock uses trees of
integers to represent both code and data. Nock is aggressively tiny; the spec
linked above is just 33 terse lines.
Next, Guy provides the rationale for Nock. In short, he asks how a
planet-wide computing infrastructure (OS, networking, and languages)
would look if designed from first priniciples for robustness and
interoperability. The answer he proposes is Urbit: a URI-like namespace
distributed globally via content-centric networking, with a feudal
structure for top-level names and cryptographic identities.
Urbit is a static functional namespace: it is both referentially
transparent and monotonic (a name, once bound to a value, cannot be un- or
re-bound).
Why does this require a new formal logic and a new programming language? In
Urbit, all data and code are distributed via the global namespace. For
interoperability, the code must have a standard format. Nock's minimal spec
is meant to be an unambiguous, unchanging, totally standardized basis
for computation in Urbit. Above it will be Watt, a self-hosting language
that compiles to Nock. Urbit itself will be implemented in Watt, so Nock and
Watt are designed to treat data as code using metacircular evaluation.
The code
A prototype implementation of Watt is on GitHub. It is not yet
self-hosting; the current compiler is written in C. Watt is a functional
language with static types called “molds” and a mechanism for
explicit lazy evaluation. (I was suprised to find I had accidentally created
an incompatible lazy dialect of Nock – despite its goal of
unambiguous semantics – just by implementing it in Haskell.)
The code is not fully documented, but the repository contains draft specs for
both Watt and Urbit. Beware: the syntax and terminology are a bit
unconventional. Guy has offered a few exercises to help get started with Nock
and Watt:
The Nock
challenge: Write a decrement operator in Nock, and an interpreter that can evaluate it.
Basic Watt: Write an integer square root function in Watt.
Advanced Watt:
How would you write a function that tests whether molds A and B are
orthogonal (no noun is in both A and B)? Or compatible (any noun in A is
also in B)? Are these functions NP-complete? If so, how might one work
around this in practice?
If you want to learn more, start with these problems. You can email your solutions to
Guy.
Will it work?
I find Urbit intellectually appealing; it is a simple and clean architecture
that could potentially replace a lot of complex system software. But can we
get there from here?
Guy imagines Urbit as the product of an ages-old Martian civilization:
Since Earth code is fifty years old, and Martian code is fifty million years
old, Martian code has been evolving into a big ball of mud for a million
times longer than Earth software. (And two million times longer than
Windows.) …
Therefore, at some point in Martian history, some abject fsck of a Martian
code-monkey must have said: fsck this entire fscking ball of mud. For lo,
its defects cannot be summarized; for they exceed the global supply of
bullet points; for numerous as the fishes in the sea, like the fishes in the
sea they fsck, making more little fscking fishes. For lo, it is fscked, and
a big ball of mud. And there is only one thing to do with it: obliterate the
trunk, fire the developers, and hire a whole new fscking army of Martian
code-monkeys to rewrite the entire fscking thing.
… This is the crucial inference we can draw about Mars: since the
Martians had 50 million years to try, in the end they must have succeeded.
The result: Martian code, as we know it today. Not enormous and horrible
– tiny and diamond-perfect. Moreover, because it is tiny and
diamond-perfect, it is perfectly stable and never changes or decays. It
neither is a big ball of mud, nor tends to become one. It has achieved its
final, permanent and excellent state.
Do Earthlings have the will to throw out the whole ball of mud and start from
scratch? I doubt it. We can build Urbit but no one will come, unless
it solves some problem radically better than current software. Moldbug thinks
feudalism will produce better online reputation, but feudal reputation
does not require feudal identity; it is not that much harder to build
Moldbug's reputation system on Earth than on Mars. I still have not figured
out the killer app that will get early adopters to switch to Urbit.