Urbit Is Building a 'Virtual Galaxy' for Bitcoin Nodes

And what is the advantage of this over wordpress? Or even just raw nginx?

I don't necessarily mean what is the advantage of urbit in its current state -- I get that this is an alpha release. What I'm asking is: when urbit becomes what you envision it to be, what tangible advantage should I as a user expect to see from using Urbit over using Wordpress or nginx?

(Although tying your fate to Etherium may be a mistake. The contract technology turned out to be insecure, and very hard to secure. Etherium needs to go back into the shop for a major redesign.)

It is entirely unclear this has been demonstrated. Mostly what we see in the cryptocurrency space in practice (not hypotheticals) is scams upon scams: it turns out that a "trustless" system attracts people who can't be trusted.

Comparisons to Bitcoin are bound to fall apart upon closer examination. For instance, Urbit has no blockchain, and Bitcoin's ownership structure is based on computer power, not federated cryptography.

Digging a bit deeper, Urbit is actually more free than Bitcoin, because the latter is easily eaten by the biggest fish in the sea. Urbit, on the other hand, could only ever de-decentralize if all 255 galaxies were owned by a single person, which is about as likely as all of the Eastern Hemisphere being owned by a single person.

* Everything on the VM is purely functional, and inputs essentially cause transactions which can fail/succeed - the result being that it's supposedly easier to implement certain types of network protocols, specifically the ones that Ames implements

* A somewhat decent revision-controlled filesystem with push/pull/merge, static typing of files, and a built-in build system of sorts

And last but not least...

* Feudalism built into the core p2p protocol as an explicit design decision

Bignums themselves are somewhat expensive data structures to pass around, so runtimes that use them usually don't use them for everything; instead, they have an Integer type that has Bignum (data-structure on the stack, or pointer to data structure on the heap) and Fixnum (regular integer machine-register) implementations, and write a glue layer to treat the two interchangeably.

So, you've got a runtime where your only "type" is an integer, but it breaks down into "cheap integers" and "expensive integers."

Now, in most dynamic-language runtimes (i.e. runtimes where type-tagging and pattern-matching doesn't all happen at compile-time), you want a type that "represents itself" to use for type-tagging, dictionary keys, function references, etc. This is usually a Symbol or Interned String (or Atom!) type, with the runtime keeping a symbol table mapping fixnums ('cheap integers') to strings (which are effectively, in Nock, 'expensive integers'). You need this table, because dynamic language functions manipulate/build/pass around/compare a lot of symbols, and the interpreter would be really slow if you were passing and comparing 'expensive integers' by value.

But Nock can't really keep a symbol-table, because every "atom" ID embedded in a Nock program is a universal ID, a handle any other Nock runtime might be passed and attempt to manipulate. (And you can't even use a global symbol-table that uses hashing—i.e. a DHT—because Nock doesn't differentiate the "Symbol" atoms from any other atoms, so you'd have to treat every atom the same and hash them all—and, even pretending that's cheap, you're eventually going to get collisions that way.) The only symbol table that works in a globally-distributed system is one that maps bitstrings to themselves. And that's as good as no symbol table at all.

So what do you do when you can't make your strings ('expensive integers') into interned strings ('cheap integers')? Just use the cheap integers from the start! In Nock, this means that all the runtime-defined symbols—all the atoms in the language and the stdlib—are bitstrings that are short enough to be encoded directly as fixnums. Since Nock has the requirement of running on 32-bit machines, that means 32-bit bitstrings: four-ASCII-character strings. Thus most of the jargon.

Do note, it's not required to use four-letter names for "symbols" you manipulate in the Nock runtime; but doing otherwise means passing around 'expensive' handles instead of 'cheap' ones.

---

I find Urbit's solution here interesting—but they probably chose it for purity's sake.

I would like to contrast it to the implementation in Erlang's BEAM runtime (which also, coincidentally, has 'atoms', but where these are simply its particular symbol type):

• an atom table is kept by each "node", with no need for the atoms in each node to have identical mappings;

• atom IDs are mapped back to their original bitstrings when serializing any data structure including them, even if just for internal persistence;

• each distributed-RPC connection between nodes is stateful, keeping its own atom table (kept synchronized on both sides by additional messages) as a cache to speed up communication between nodes. This can be seen to be similar to a streaming compression algorithm's Huffman tree cache, but it's interesting to look at it as the connection being its own virtual 'node' that has this particular atom table, which both nodes are then modelling and translating to/from.

Addresses can actually be up to 128-bit. I think the idea is that addresses longer than 32-bit are just assumed to be bots, but that convention would probably be changed if Urbit gets popular enough for the 32-bit limit to matter.

No, it's much uglier than Newspeak.[0]

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

OK, that was just perverse. Except check out the latest iteration of point of sale credit card terminal keypads. "0" is Yes and "X" is no.

It's not a terrible idea. In most types of computing there's often only one way for something to be true but N ways for it to be false.

A core axiom of Moldbug's philosophy is that the mathematicalization of computing is an elitist conspiracy. As an example, he thinks that the lambda calculus is intrinsically mathematical, hence elitist, whereas his own concatenative language is non-mathematical, hence non-elitist, by conforming to human nature. It's bizarre to say the least given that his proposed language has an obvious relationship to combinator calculi like SKI calculus, and you'll have to look long and hard to find anyone who thinks the SKI calculus is more intuitive than the lambda calculus.

> The level below main memory contains rotating magnetic disks that take millions of clock cycles to access. Because of the great discrepancy in access time, no one has yet built a virtual memory operating system that writes through main memory to disk on every store by the processor. (This remark should not be interpreted as an opportunity to become famous by being the first to build one!)

Do we really need a new everything? What problems do these new things solve that couldn't be addressed through other mature technologies used in new and novel ways?

Maybe we do, but if that's the case they've done a terrible job of articulating why.

Most importantly: How can you possibly secure all these things given the complex nature of interactions between all of them?

Can you confirm that all galaxies save ~zod are signed by ~zod? I'm presuming here ~zod isn't self-signed.

If it's the latter I can see how 'second hand space' really is a bad idea as there's no way to enforce the transfer of a private key.

A couple observations -- The stars were underpriced, by how much it's hard to know. If your goal is to seed the owner class with random giveaways, this was a success, I suppose. Second, 1020 stars was a HUGE amount to give away. I thought perhaps you would pre-sell one star's share of planets for $1 /ea. $205 for a star is nothin.

From my armchair, what I would suggest is to focus on developing a secondary market for urbit addresses PRIOR TO any further crowdsale. That way you can get some indication of demand before pricing another Tlon-organized event.

Presumably $209k is not interesting money, even to Tlon. It's a shame you gave away 1% at that price but maybe will work out in the end as a way to bootstrap the network with early enthusiasts.