./backlog: Charlie's blog

meanderings through tidbits of mathsy computery stuff

Fixing the UX of IP Addresses

Remembering IP addresses has long been a pain point for system administrators. They're long, clunky and difficult to remember - essentially a 12-digit phone number for internet-connected machines. Trying to remember the IPs of the endless reams of servers that you manage (was it x.x.x.y? or was it y.y.y.z?) is difficult - after all, that's why we have DNS.

Trying to remember or communicate all 12 digits (which can be up to 20 syllables long!) is a cognitively demanding task. When we examine the limits of short term memory, it appears that the average person is capable of recalling between 5 and 9 abstract pieces of information - a figure which can easily be reached when trying to remember one or two IPs.

What if we could make IPs easier to remember by reducing the cognitive overhead? What if, instead of some abstract and oft-meaningless list of numbers, we could turn IPs into real, pronounceable words? What if, instead of 20 syllables, we could reduce an IP address to 8 syllables (or fewer) - and make it pronounceable?

There are several approaches that we can take to solve this problem:

  • Map the digits of an IP to pronounceable syllables
  • Use a pre-defined list of unique words to map IP chunks to words

In this blog post, we'll look at each approach and see which works best.

IPs as syllable groups

OK, so let's look at our first option; mapping individual digits to syllables. Let's look at some numbers. In the case of IPv4 addresses (I'll refer to IPv4 addresses as IP addresses from this point) there are four groups of integers, ranging between 0 and 255 respectively. That gives us 256 possibilities for each digit - giving us 256⁴ possible combinations for an IP address, or 4,294,967,296 combinations. Obviously, there aren't that many pronounceable syllables (or in fact, words in the English language) - so mapping a single syllable to an IP address as a whole is out of the question. That seems obvious.

However - what if we reduce each group in an IP address to an arbitrary base (e.g. base-16), and map each resulting digit to a syllable? Conveniently, in base-16, any integer between 0 and 255 can be represented by only two digits. For example, in base 16, the IP address looks like this: 7F.0.0.1. The IP address looks like this: 2D.3F.2B.40. Mapping these individual digits to syllables will give us four two-syllable "words", which will hopefully make for a easier-to-pronounce IP address. Something like this, perhaps;

2che10 (Hex: A)mo
3do11 (Hex: B)na
4fu12 (Hex: C)ra
5ra13 (Hex: D)te
6ko14 (Hex: E)zo
7ka15 (Hex: F)zu

Using this format, the IP would become kazu.ba.ba.bo, and so on. This is better! I'll show a few more here;

IPBase-16 NumberSyllable-Encoded Result

However, these semi-meaningless strings of syllables are a little abstract - definitely still quite difficult to remember, even if they are a little easier to pronounce. This brings us to the next possibility.

IPs as word pairs

Sticking with the a similar principle to before, it's possible to map words to IP addresses. If we can come up with a long list of distinct words, then it's possible to map an IP address to a unique phrase (à la "correct horse battery staple"). Better yet, if we can come up with a list of 65,536 different words (65,536 is 256²), we can reduce the number of words needed to represent an IP address by a factor of two - that is, we can represent an IP address with only two words! Notably, this is somewhat similar to the naming scheme for URLs at GFYCat (e.g. https://gfycat.com/AthleticTinyBeauceron).

Let's give this a try. I have acquired a list of ~91,000 nouns from here. I have then converted each word to lowercase, ensured there were no duplicate words, selected 65,536 words from the list entirely at random (using the shuf -n 65536 Unix command), and written this out to a new file. Now we can now start thinking about converting IPs to phrases.

We can essentially treat an IP address (4 groups of integers between 0-255) as a base-256 number with 4 digits. What we need to do is convert that base-256 number to base-65536 - which, conveniently, can represent an entire IP address in two digits. Once that's done, it's easy to look up the corresponding word for each digit. For example, in base-65536, the IP address becomes 32512.1, becomes 2056.2056, becomes 11583.11072, and so on. If we have that list of 65,536 words handy, then it's quite simple to look up the word corresponding with each digit in the base-65536 number, and therefore come up with a memorable phrase to refer to each IP uniquely. For example;

IPBase-65536 NumberWord-Encoded Result

"What about IPv6?"

I haven't specifically mentioned IPv6 addresses in this blog post - mostly because it's late and I should be in bed, but partly because exactly the same principles apply to IPv6 - in fact, if my back-of-the-metaphorical-envelope calculations are correct, it's possible to represent an IPv6 address by using 8 unique words (assuming we're using the same 65,536 word dictionary from earlier) - which is definitely an improvement on an incomprehensible 128-bit hexadecimal string. I've got a much better chance of remembering 8 words than I do of 32 hexadecimal characters - and let's face it, any improvement we can make to the usability of IPv6 has to be a Good Thing™.

In fact, let's try it here.

IPv6 AddressWord-Encoded Result
calibrations:borsch:exclusives:accentor: ...

Note that, on the second IPv6 address I had to truncate the result as the word encoding was too long to fit on the page! Perhaps a small side effect. :)

In conclusion

What have we done? We've improved the pronounceability and memorability of the humble IP address by using base-n trickery and large dictionaries of memorable nouns to re-encode them into something a bit... nicer. Not only do these approaches reduce the number of syllables to encode an IP address, but they also increase pronounceability, memorability, and overall friendliness. Isn't coffers.claytonia much easier to say than I certainly think so.