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:
In this blog post, we'll look at each approach and see which works best.
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
127.0.0.1 looks like this:
7F.0.0.1. The IP address
126.96.36.199 looks like this:
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;
|2||che||10 (Hex: A)||mo|
|3||do||11 (Hex: B)||na|
|4||fu||12 (Hex: C)||ra|
|5||ra||13 (Hex: D)||te|
|6||ko||14 (Hex: E)||zo|
|7||ka||15 (Hex: F)||zu|
Using this format, the IP
127.0.0.1 would become
kazu.ba.ba.bo, and so on. This is better! I'll show a few more here;
|IP||Base-16 Number||Syllable-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.
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.
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
-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
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
|IP||Base-65536 Number||Word-Encoded Result|
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 Address||Word-Encoded Result|
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. :)
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.
coffers.claytonia much easier to say than
188.8.131.52? I certainly