For a number of years I have been using UUIDs as intentionally meaningless names for objects like Web pages, to be able to publish them without having to name them right away. When I finally decide on a name (which usually entails deciding on the document's title), I simply redirect all requests from the UUID to the new, human-readable address. This way I don't lose any inbound links that may have accrued in the interim.

UUIDs For Greater Living

The humble universally unique identifier is actually a pretty clever invention. The problem the UUID solves is that objects (on computers) often need to be addressed by name, but it is too onerous to come up with a scheme for doing so. It is also important that no two objects receive the same name anywhere in the world. The UUID makes such collisions extremely unlikely by being so huge, numerically, that an accidental duplicate would effectively take forever to generate.

The problem with UUIDs, however, is that they look like this: 38f9b5ee-c1d7-44f5-b294-295db67998fd—wholly unfit for human consumption. They exhibit no mnemonic value because they aren't supposed to. Even after years of exposure to abstruse alphanumeric strings, I can never remember more than the first few digits—and it doesn't take more than a few hundred objects named this way for the first few digits to start to collide. This is a known problem that I have considered before: that it would be useful to turn this computerrhea into something more memorable.

My previous work along this line of inquiry was around cryptographic hashes, which is a similar problem with a different goal: to visually match a symbol we have with one we are given. This problem differs in that we want to pick an individual object out of a lineup. Here are some examples of the very primitive proof-of-concept I did for the hashes, in which I mapped bits in the symbol to blocks of grey, adapted to UUIDs:

Symbol Image
98538aca-57d2-4a54-9057-7120f74a75d5
2b25228e-684d-44a1-be08-3c3445979ff4
6926eac7-ee30-44fa-9a0e-d9a0b7ab7d41

Revisiting this little excursion made me realize that my other examples regarding SHA-256 hashes are wrong, because at two bits per block (four shades of grey) there should be 128 blocks, i.e. twice as tall or wide as those above, which, at √128/2 = 8 blocks square. Also, they look way too much like QR codes.

Perhaps We Can Make This More Interesting

I thought to myself how it would be more memorable if instead of pixel grids, the data in these symbols drove geometric shapes, like Vash or Chernoff faces:

Almost a good idea, but what about flags, or heraldry? It should be feasible to cram 128 bits of entropy into a mishmash of stripes, lozenges and heraldic critters. These things don't have to be conspicuously exact like cryptographic hashes, they just have to be close enough. UUIDs also have a discernible anatomy and come in five different flavours: two based on time, two on hashes and one random. One could incorporate the season or time of day the symbol was minted (in the case of time-based UUIDs) into the generated image. Plenty of fun to be had with it.

Anyhow, this is born onto the back burner, because I have way too many projects going on at the moment. If anybody tries this though, let me know.