
Urbit: an operating function - privong
http://urbit.org/preview/~2015.9.25/materials/whitepaper
======
pcmoore
For a more accessible alternative approach to all this madness see this mirror
project

[https://github.com/tibru/tibru](https://github.com/tibru/tibru)

~~~
yarvin9
They do say noitatimi is the highest form of yrettalf...

~~~
agumonkey
You're such a snoc.

------
csense
The architecture is exciting. The problem is that the aesthetics of the
tooling seems deliberately designed to alienate new users. For example the
whitepaper gives new names to every punctuation symbol!

And poking around the repo, there are gems like this:

"A...variable name is a random pronounceable three-letter string, sometimes
with some vague relationship to its meaning, but usually not..."

"Nock, for mysterious reasons, uses 0 as true...and 1 as false..."

The architecture is really cool, but the syntax is terrible.

~~~
pcmonk
Traditional punctuation names suck. "Ampersand", "at sign", "caret"? For a
language like hoon where we use a lot of symbols, that gets really tiring.
Having one-syllable names for glyphs is really convenient, and they tend to
roll of the tongue. Everyone's free to use whatever names they want, of
course, we just find these useful. Most people love these once they get used
to them.

I don't think you can judge syntax by looking at it -- you have to use it for
a little while. Hoon's syntax looks hard, but it's actually rather pleasant to
use.

~~~
tptacek
This right here is what I mean when I suggest Urbit is unserious. "Green is
just yellow and blue. Why do we call it 'green'? That name sucks. From now on,
we're going to call it 'yellue'."

There's overreaching first-principles boil-the-ocean dorm room rethinking of
concepts, and then there's renaming the ASCII characters.

~~~
yarvin9
This definitely counts as a highbrow dismissal!

As I age, I find it harder and harder to remember how easy and natural it is
for young people to learn new things: ideas, theories, languages, and yes --
names. Alas, we can't rejuvenate our brains. I know of only one (partial)
cure: have your own kids. You'll feel jealous all the time, but it's worth it.

It's painful to admit that I'm probably too old to learn other peoples' new
languages. But any new language isn't and can't be designed for 42-year-old
silverbacks. It has to be designed for kids -- or at least, people are who are
kids now. And believe me, teenagers love this kind of stuff...

[Edit: tptacek, when you edit a comment after posting it, I think it's good
etiquette to mark it with an [edit]]?

~~~
tptacek
FWIW: I wrote the first half of that comment, then 5 minutes later, feeling it
was too snarky without explaining itself, added the sentence: "There's
overreaching first-principles boil-the-ocean dorm room rethinking of concepts,
and then there's renaming the ASCII characters."

I'm a parent of two teenagers, neither of whom seems particularly interested
in new names for punctuation.

~~~
yarvin9
I understand. And it did improve the comment, so I forgive you. But it's just
irritating when someone hangs a fat fastball over the plate, you whack it,
then find out that the pitch magically turned into a curveball and all you've
hit is a ground-ball single.

An XS Nock shirt is a dress for my daughter, but she loves the "code." I guess
all kids are different. But you never know what they're ready to learn until
you try to teach them.

------
fiatjaf
The aesthetics is what is making this thing possible. Thinking with the old
words would not allow development of new things.

I don't know if this is good or bad, but it is sincerely trying to do new
things, so a new language is appropriate.

~~~
Rusky
New things are developed every day with old words. There are existing words
for just about everything Urbit does.

~~~
fiatjaf
You didn't get it. Not radically new things. There are existing words, but
using them wouldn't allow the people from Urbit to think about combining
concepts in the radically different way they are doing.

In fact, they would end up saying: well, all we are trying to do already
exists, so let's just write a library here, another there. You can argue this
would be better, but their goal is to do a completely different thing, even if
it looks it could be done with a new library for something.

~~~
Rusky
No... I got what you meant. But there are plenty of new languages and even
reinvent-the-world projects that reuse existing terminology just fine. There's
nothing about using existing words that makes it harder to "develop new
things"\- in fact, it makes it easier.

------
jitl
the concepts expressed in the first section "Obstacles" are interesting and
make for good reading, but the implementation strategy in "Definition" are
nuts. The authors completely disregard human nature and usability when
designing Hoon. Random variable names? Sigils-only syntax? If they want to
replace Unix and the Internet, they should remember why Unix won: because it
was easy tp get things done.

In Urbit new developers not only have to learn all the new concept words, they
also have to suffer through a brainfuck/perl syntax and a hostile programming
style. Success seems impossible.

~~~
yarvin9
Apparent usability isn't the same as actual usability. Pretty much everyone
who learns Hoon is surprised by how easy it was, which may be a good thing or
a bad thing depending.

There are about a hundred runes (digraphs) in Hoon, but you mostly see only 10
or 15. Also, they're organized by internal structure (all | runes do the same
kind of thing), and most runes are macros which resolve to about 20 built-in
forms. It's a couple of orders of magnitude easier than learning Chinese,
which again may be a good thing or a bad thing.

Variable names designed to be memorable rather than meaningful are pretty
normal in both math and functional programming. Math uses Greek letters for
the same purpose, for instance. Also, as we note explicitly, this is a style
that's optimal for simple code - in any language, you'd probably write add(a,
b), not add(left_argument, right_argument).

Actually, Perl originally won because it was easy to get things done. It's had
problems since, but for different reasons...

~~~
mst
Every time I look at Hoon I think "this looks like the same sort of cliff-
steep startup followed by 'woah' as vi", but I can never quite get past the
cliff as yet.

~~~
yarvin9
That's exactly what we want you to think. :-)

Don't worry, we'll put up some ropes...

------
masonicb00m
Awesome.

'For example, %= sounds like "centis" rather than "percent equals." Since even
a silent reader will subvocalize, the length and complexity of the sound is a
tax on reading the code.' This is great. Clever how some of the sounds are
reminiscent of existing readings.

~~~
david-given
"Since even a silent reader will subvocalize..."

Actually, no. I don't.

~~~
yarvin9
"Subvocalize" has a literal meaning (micro-activation of the vocal cords)
which good silent readers avoid. But you're still activating the vocal areas
of the brain [0]. If you read much poetry, you'll see that the connection
between reading and sound is pretty inseparable.

[0]
[http://www.ncbi.nlm.nih.gov/pubmed/23223279](http://www.ncbi.nlm.nih.gov/pubmed/23223279)

~~~
david-given
I'm afraid I'm having a great deal of trouble understanding your point here.

> "Subvocalize" has a literal meaning (micro-activation of the vocal cords)
> which good silent readers avoid.

Right; so I'm not subvocalising.

> But you're still activating the vocal areas of the brain...

Well, sure. I see the symbol 'cat' and both the memory-complex representing a
cat and the audio complex representing the spoken version of the symbol will
be activated. That's how memory associations work. The written version of the
symbol and the spoken version of the symbol will be strongly associated,
because they represent the same concept.

But that doesn't mean I have to wait for the audio to finish playing before I
move on to the next symbol. That's a misconception of what's actually
happening.

(Plus, of course, hardly anyone reads a word at a time. It's nearly always
complete phrases. Frequently not even in the right order.)

> If you read much poetry, you'll see that the connection between reading and
> sound is pretty inseparable.

Well, no. Poetry is mostly intended to be read aloud; it's _supposed_ to be
subvocalised. It's unrelated to prose (or computer programs).

~~~
yarvin9
It definitely doesn't mean you have to wait for the audio to finish playing.
It does mean that your brain _thinks_ the audio. Which has a lot of
consequences, including the energy it takes to think...

Most people do read poetry silently, in the same way they read prose (I don't
literally subvocalize), and the sound still is everything. Try reading these
two poems silently:

[http://www.mcgonagall-online.org.uk/gems/the-tay-bridge-
disa...](http://www.mcgonagall-online.org.uk/gems/the-tay-bridge-disaster)
[http://www.poetryfoundation.org/poem/174183](http://www.poetryfoundation.org/poem/174183)

~~~
david-given
> It does mean that your brain thinks the audio.

I'm sorry, that's simply not true. At least for me. It may be true for you.

From the things you've said, I suspect you're a word-at-a-time reader,
treating words as a sequential symbol stream, processing them as if they were
speech. This is just one of the several different styles of reading. Others
exist.

I am, as I mentioned above, a phrase-at-a-time reader. I take in multiple
symbols at a time, and not necessarily in sequence. If I had to think through
the audio of a phrase, this simply wouldn't work. It also means that I would
be unable to read symbols that didn't have an audio equivalent.

Right now I'm working with Smalltalk. One of its operators is ~~. How is this
pronounced? Don't know, don't care. It's just ~~. When I perceive it, I don't
perceive 'tilde tilde'; it's a ~~.

(Also, if you aren't reading Scotland's worst poet aloud, you are _wasting_
him.)

~~~
yarvin9
I read more like a page at a time. Some might accuse me of being a page-at-a-
time writer.

Compare the way you perceive "~~" to the way you perceive "++". I hear these
as "sig sig" and "lus lus". (Or rather, as "slus," because that's a further
Hoon abbreviation, but never mind.) You don't hear the former at all; but you
hear the latter as "plus plus," don't you?

This is because "tilde tilde" is so heavy your brain doesn't want to do the
work of hearing it out. But overriding that connection doesn't save energy,
which is why you do hear "plus plus." Your brain has to think the very
complicated little thought, "squiggle I don't want to pronounce." It would
much rather have a sound.

It's torture enough to read McGonagall silently. Out loud? Who would try that?
It's tantamount to suicide.

~~~
invertedohm
> You don't hear the former at all; but you hear the latter as "plus plus,"
> don't you?

I really do not. A short silence, both of them. I suppose it depends on how
you normally code. I have never had a need for speaking out code and am not
well versed in it.

~~~
jeremysalwen
I experience reading similarly to you. I will often become familiar with
written words before I know how to pronounce them. When I want to say the word
for the first time, I will have to pause and think about how it would sound
out loud.

This is especially true of code and symbols. For example, consider this poem

> is it already too dark > to play tennis with a racket > i asked? > while I
> code with [

and contrast with this one

> The house filled with laughter > from mother and daughter > Both were fiends
> > but neither friends

or even better, combine the two

> I never used a ~ > as well as Oscar Wilde

------
fit2rule
Interesting stuff, but in my usual 15 minutes of attention-span for things
like this, utterly impenetrable. Can anyone who has had the privilege of being
invited to the Urbit network enlighten us as to just how useful it is shaping
up to be in light of, say, the situation with IPFS by comparison?
([http://ipfs.io](http://ipfs.io)) Because to me, it seems that IPFS may well
be ahead in terms of actual applicability right now. Am I mistaken?

~~~
akhilcacharya
>Interesting stuff, but in my usual 15 minutes of attention-span for things
like this, utterly impenetrable.

It's pretty much designed to be as hard to understand as possible.

Look at the source/demo videos - it seems like it's designed to be obfuscated.

[https://github.com/urbit/urbit](https://github.com/urbit/urbit)

[http://urbit.org/preview/~2015.9.25/materials/part-i](http://urbit.org/preview/~2015.9.25/materials/part-i)

Personally, I can't get over the really made up words.

~~~
jpt4
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/](http://www.ucombinator.org/)

[1]
[https://en.wikipedia.org/wiki/Abstract_rewriting_system](https://en.wikipedia.org/wiki/Abstract_rewriting_system)
(ARS being the most mechanical of the pure computational models outside
reversible logic)

[2]
[http://tunes.org/wiki/symmetric_20lisp.html](http://tunes.org/wiki/symmetric_20lisp.html)

[3]
[https://en.wikipedia.org/wiki/Forward_chaining](https://en.wikipedia.org/wiki/Forward_chaining)

[4]
[https://en.wikipedia.org/wiki/Modula-2#Description](https://en.wikipedia.org/wiki/Modula-2#Description)
(see Definition/Implementation modules)

[5]
[https://en.wikipedia.org/wiki/Content_centric_networking](https://en.wikipedia.org/wiki/Content_centric_networking)

[6] [http://netcentriccomputing.org/](http://netcentriccomputing.org/)

[7] [https://en.wikipedia.org/wiki/Capability-
based_security](https://en.wikipedia.org/wiki/Capability-based_security) (not
yet fully implemented)

[8] [http://moronlab.blogspot.com/2010/01/moron-lab-goals-
princip...](http://moronlab.blogspot.com/2010/01/moron-lab-goals-principles-
rules.html)

[9] I won't say full stack, because the reshaping blade only penetrates OS
deep. For a hardware-grounded reset, see good old Loper OS ([http://www.loper-
os.org/?p=8](http://www.loper-os.org/?p=8)).

[10] Because words are context dependent, this expansion is only logarithmic
with respect to the increase of immediately referable concept space.

~~~
akhilcacharya
That's not at all the thing that I have the hardest time understanding, you're
right - it's just the thing, along with CY's past, that makes me stop taking
it seriously, although it is an interesting idea if it were implemented in a
way that didn't attempt to be as arcane as humanly possible.

~~~
jpt4
Arcanity is relative to experience, so the ASCII phonemes can indeed be the
most stymieing element of this experiment in futurity. However, what do you
think of the phonetic numeral system? Compared to other protocols that map
identity to a unique point sha256 space, "~hex" is no worse than "46", and
"~fantyv-ralpen" is obviously better than whatever is its corresponding
number; Urbit's vocalizable number to name mapping is possibly its most
obviously correct (to me) and portable innovation.

------
_m19m
This seems to come up at regular intervals. It's worth noting that the
architects of this system are the "facist teenage Dungeon Master[s]" of
[http://thebaffler.com/blog/mouthbreathing-
machiavellis](http://thebaffler.com/blog/mouthbreathing-machiavellis)

~~~
asdaqeqweq
That doesn't seem worth noting.

------
pcmonk
Front page with demo videos: [http://urbit.org](http://urbit.org)

~~~
jpt4
Currently under delightfully heavy load, it would seem, since I can icmp but
not http it.

~~~
pcmonk
Sorry, whenever we push updates we have a brief period of inavailability.
Should be working now.

------
a-dub
The backup plan is to typeset and publish the mailing list as a
collaboratively written science fiction novel in the event that the main
project fails...

------
xena
This is a really interesting read. I'm excited for urbit now!

------
fiatjaf
The best tagline for the project is what is written on the whitepaper, that a
planet in Urbit is "the browser for the server side."

------
ClintEhrlich
The flaw in this white paper is that it starts by explaining the solution
instead of the problem. So everyone should start by skipping to the bottom and
reading the conclusion:

>In 1985 it seemed completely natural and inevitable that, by 2015, everyone
in the world would have a network computer. Our files, our programs, our
communication would all go through it.

>When we got a video call, our computer would pick up. When we had to pay a
bill, our computer would pay it. When we wanted to listen to a song, we'd play
a music file on our computer. When we wanted to share a spreadsheet, our
computer would talk to someone else's computer. What could be more obvious?
How else would it work? . . .

>The Internet didn't scale into an open, high-trust network of personal
servers. It scaled into a low-trust network that we use as a better modem — to
talk to walled-garden servers that are better AOLs. We wish it wasn't this
way. It is this way.

This is the problem Urbit aspires to solve: _Why does everything suck_? Why
aren't we living in the future we were promised in 1985, where everything is
easy because all software plays nice together? Why do we have a planetary
series of Rube Goldberg machines instead of the fun version of the Borg?

The answer is that we've been building everything on top of leaky abstraction,
piling band-aids on top of band-aids instead of just starting with a stable
foundation. Urbit's solution is to replace every OS, file system, and
communications protocol on Earth with a single application: Urbit.

The project is _meant_ to be the biggest pain in the ass ever. It's an attempt
to fix everything that is wrong with computers by rebooting the entire
information age.

The beauty is that it doesn't all have to happen at once. Urbit can function
like a kernel for all non-Urbit systems: They get to call Urbit to receive its
super-reliable data, but it never makes system calls so they can't inject side
effects into the shiny new Urbit ecosystem. Over time, if Urbit works as
intended, it will assimilate everything else.

Once you understand the stakes, Nock and Hoon no longer look like cruel jokes.
It would be madness to expect coders to invest all that effort to learn 'just
another language.' It's only pseudo-madness to make the same demands while
promising that their code will still work a million years from now, because
all computers will still be running Urbit.

Instead of caviling about details like how to pronounce the code when reading
it aloud, let's delve into the issues that really matter:

I. Does modern computing suffer from a leaky abstraction problem that needs to
be solved?

II. If so, is the solution to build an overlay network that provides a global
static functional namespace?

III. If so, is Urbit a viable implementation of that solution?

IV. If so, what is the likelihood of Urbit reaching the critical mass
necessary for mass adoption?

The last question is the one that interests me the most. In order to overcome
the massive inertia behind legacy computing, Urbit needs a killer app:
Something that exploits the new system's intrinsic advantages to accomplish
feats that were previously impossible.

So... uh... Any suggestions?

~~~
yarvin9
A hint: consider the difference between calling web APIs from a cloud
appliance controlled by a third party, versus calling web APIs from a personal
server controlled by the user.

A new network has no Metcalfe's law effect by definition. So an important
early skill is parasitizing existing networks...

------
norswap
I've always heard: do one thing and do it right. It's the Unix philosophy,
before it was totally disregarded.

Urbit seems to take the total counterpoint of this advice, and I wonder
whether it's a good idea.

What I don't get is what it is trying to achieve. The stated goal are too
abstract. What are some use-cases? Is it really necessary to scrap the whole
OS and languages to achieve these goals?

I do sympathize with the idea of rewriting everything from scratch, and I too
feel that "almost everything is terrible" in software-land. But I doubt
rewriting everything without having a firm grasp on the underlying issues is
the way to go. It it a fun exercise, and inspiring besides, but I'm unsure it
can be more than that.

------
KaiserPro
isnt this basically the same idea as plan 9, but with some more opinions on
"decentralised" networks.

~~~
jpt4
To the depths of my familiarity, Urbit is basically the same, to some shade or
degree, including but not limited too, the ideas listed here:
[https://news.ycombinator.com/item?id=10279931](https://news.ycombinator.com/item?id=10279931)

------
kopter
If things are really so screwed up, and we need to recover the dreams of the
past, why not "recurse on the idea of the computer", and invest in something
like Pharo Smalltalk instead?

------
kungfooguru
Reading anything from them always reminds me of TempleOS. There are some
hilarious gems if you skim it, like "Urbit is highly intolerant of computation
error, for obvious reasons, and should be run in an EMP shielded data center
on ECC memory."

~~~
MichaelAza
I always think of TempleOS as well. Both project maintainers have created some
impressive and/or interesting technology that is hindered by inflated self
importance and being different for the sake of being different. Another common
point - HN has a soft spot for both and upvotes most content related to these
projects.

~~~
yarvin9
It'd be interesting to hear a more detailed description of what you'd classify
as "different for the sake of being different."

There's certainly plenty of code in this world that's the same for the sake of
being the same. It's not terribly interesting to use CGA graphics for the sake
of being different. On the other hand, I do wonder whether my children will
grow up learning 1970s programming for the sake of being the same.

~~~
deegles
One example is that they flipped the meaning of 0 and 1 in their new language.

>We should note that in Nock and Hoon, 0 (pronounced “yes”) is true, and 1
(“no”) is false. Why? It’s fresh, it’s different, it’s new. And it’s annoying.
And it keeps you on your toes. And it’s also just intuitively right.

~~~
yarvin9
I'll give you that one! It's an old mistake and not very costly in practice,
but the intuitive rightness isn't worth the pain in the butt. But the pain in
the butt also isn't painful enough to match the difficulty of fixing it.

I actually got this bad idea from Unix: !strcmp(), etc. It's certainly easier
to overload error codes into a 0=true scheme, although Urbit doesn't actually
do that.

~~~
david-given
"It's an old mistake and not very costly in practice, but the intuitive
rightness isn't worth the pain in the butt."

Why is it intuitively right?

~~~
melloclello
"a string can be slack in many ways, but taut in only one"

0 is true, everything else is false. At least that's my intuition.

~~~
emmelaich
Huh! Pretty similar to my comparison to Tolstoy's quote on happy and unhappy
families.

[https://news.ycombinator.com/item?id=10282933](https://news.ycombinator.com/item?id=10282933)

------
throwawayyay123
I think it's important to note that Urbit - a very interesting piece of work
that deserves more attention - would've been presented at Strange Loop if not
the PC crowd made Strange Loop disinvite Curtis Yarvin (the creator of Urbit)
for reasons unrelated to Urbit. Using throwaway for obviously reasons.

~~~
yarvin9
I obviously find this a very interesting subject. However, I suspect there are
better times and places to discuss it...

~~~
throwawayyay123
I don't mean to take attention away from the real conversation here. However,
there are a lot of people who are unaware of the back story, and this seems
like a good place to make people aware of it.

------
toothbrush
JavaScript needed to be able to read text document. Next.

------
SrslyJosh
I got as far as the first mention of Hoon, and then I thought to myself, "Oh
fuck, didn't I read this a year or two ago?" It's all downhill from there.

------
gkya
I do computing daily i.e. I use the internet like anyone else, and I use Emacs
for feeds, mail, writing, programming little tools in elisp etc. Now after
having read this, I cannot see how it be supposed to improve my daily
computing routine. I think that it is indeed revolutionary this Urbit thing,
in that it is as opaque and unpractically idealistic as any other revolution.

------
JulianMorrison
"Do users want their own general-purpose personal cloud computer?"

No, they do not.

General purpose computers, as such, are useless and boring. They are only
useful when converted into one or more appliances. Modern OSes are very good
at this. Cloud general purpose compute exists. Its niche to the community of
appliance builders, because nobody has any use for it directly.

~~~
fiatjaf
"in the cloud, all users have is a herd of special-purpose appliances".

The argument of the whitepaper is that our current internet and Unix
environment does not allow for anything else than a cloud with lots of
special-purpose appliances, but that does not mean this is the desirable
situation, neither for the appliance builders nor for their users.

