Moron Lab

You mean that out of all the things in this combinator [0] flavored abstract rewrite system [1], programmed via a symmetrical [2], forward-inferenced [3] typed language, exposing modula-2 style per-code-block compilation control [4], all designed to support a content centric [5], natively networked [6] global computing environment with sovereignty-hard siloing capabilities [7],
the most difficult part to understand is the naming scheme?

Edit: In the early Urbit docs [8] there was a nigh ad nauseam emphasis on the "stupidity" of the project. What the epiphany of careful inspection revealed was that this stupidity was not that of intellectual deficiency, but rather opposition to "cleverness" of the kind that tends to foster (and infest) Urbit's peer group of deep stack [9] rebuilds. One of the most insightful comments I've heard after springing Urbit on unsuspecting PL professionals was (paraphrased): "It [Urbit] does all the things we've said we wanted, in the worst possible way." All words are equally made up until grounded in referents. The question is, are the Worfian shorthands new words provide worth the cost [10] of expanding the symbol table, as compared to the interpretation overhead of translating new concepts into old? Under the burden of internalizing all the content linked below and more, I judge new vocabulary justified.

[0] http://www.ucombinator.org/

[1] https://en.wikipedia.org/wiki/Abstract_rewriting_system (ARS being the most mechanical of the pure…

The thing that got me interested in Urbit when it was first announced back in 2010 was reading Van Jacobson's "Networking Named Content" paper [1] and related work from PARC, referenced in this blog post [2]. As someone who has spent 15 years now working on web development, browser development, and web standards, I feel the Internet really needs some form of "named data" networking as its next big step. I don't know if Urbit is the way it's going to happen, but it'll happen somehow. Maybe we'll evolve browsers and HTTP into a named data network instead. (On the one hand, it would be orders of magnitude easier than building an entire new model of computing from scratch... on the other hand, you don't get to throw out the whole ball of mud if you just keep building on top of it.)

Anyway, I encourage everyone to read the Van Jacobson paper or watch the tech talk. It points out some assumptions that are so baked into our network architectures that I had never really thought about them. And it gives some context for these slides' claim that "the internet has failed," by pointing to a working alternate system that's a better fit for some common cases. The link from the Urbit blog to the Van Jacobson talk is broken since Google Video was shut down, but you can now find it on YouTube [3].

[1] http://www.parc.com/publication/2318/networking-named-content.html

[2] http://moronlab.blogspot.com/2010/01/urbit-functional-programming-from.html

[3]…

"Few of us have been to Mars. But science fiction has filled in many of the gaps. We know that the Martian civilization is immensely old. Its software technology, therefore, must be similarly antique. Obviously nothing like it exists on earth - though those of us who remember VMS might be deceived...

...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...)

...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 such an obvious and essential response to the big ball of mud pattern that, despite the fact that we know nothing about Mars, we can deduce that it must have happened on Mars. Probably several times. Probably several hundred. For each of these attempts but the last, of course, the result was either (a) abject failure, (b) another big ball of mud, or (c) both.

But the last, by definition, succeeded. 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."

No comment on what follows, but you might find it…

It is open source, the hierarchy is the minimal necessary to solve the reasons federated systems fail and centralize (spam, public key lookup for p2p encryption, version updates across the system, difficulty of running a linux server).

I work at Tlon so I'm biased, but I joined because I think urbit is the best way to get ourselves out of the local max of computing we're trapped in.

Email is a failure as a federated system (people on a tiny amount of centralized providers), the promise of the web as a decentralized place for people to interact p2p failed (FB, Instagram, etc.).

We're serfs operating accounts that manipulate our attention so that we view more ads on massively centralized systems controlled by companies that have their own incentives. Urbit is an escape of that. You can't fix these issues without fixing the problems earlier up in the computing stack, federated systems on the existing stack are doomed to always be relegated to a tiny hyper-technical niche. Urbit's design means it's possible to get the UX such that everyone could use it (likely most by a provider running the urbit for them).

Federated systems don't even really solve these problems for most users unless you run your own server (an even smaller subset) - you're just trading one dictator for another (and likely it's worse given how subreddit mods behave - mastodon is a good example of…

I find the original blog posts [1] a really interesting read. Nowadays Urbit is indeed full of buzzwords, “your personal cloud computer” and the like. But initially, Urbit was this [2]:

> Urbit is a new programming and execution environment designed from scratch. Any resemblance to existing languages or operating systems is coincidental, cosmetic, or inevitable.

It was based on this idea: suppose that a different civilization (Martians specifically) had invented computing long before humans. Then by now they would have perfected it. What would their system look like? Urbit is an attempt to rethink computing without the bias of human research and our current intuition. At the heart of Urbit is Nock, a “functional assembly language”. Zero is intentionally used to denote “true” to defy programmer intuition.

[1]: https://moronlab.blogspot.com/2010/01/urbit-functional-programming-from.html
[2]: https://github.com/cgyarvin/urbit/blob/master/doc/book/0-intro.markdown

At present it's a bunch of programs that run on UNIX systems. I guess the Hoon interpreter is a C program that uses readline, talks to the network over sockets and the like. But everything on top is quite self-contained and in principle one might remove the layers underneath.

But I'm not sure that's necessarily the aim. As I understand the project's aims (and I'm not involved, I just read all the docs a few months back), it's more important that the Internet of the future is not a tangled mess of technologies that are insecure on different layers. Then it doesn't matter so what OS people's local machines are running.

I hope the essay at the URL below is still relevant, it seems to describe the aims rather well. "The result: Martian code, as we know it today. Not enormous and horrible - tiny and diamond-perfect."

http://moronlab.blogspot.co.uk/2010/01/urbit-functional-programming-from.html