Know When to Stop Designing, Quantitatively

UI Design Fundamentals

Last time, we were talking about convincing the world that interface design is more than hand waving and color preferences by using Math (with a capital “M”). If you haven’t already read that, you should go back and read it now. It’ll give this article some context. And now, we dive in.

Which of the following two sentences contains more information?

1) Cogito ergo sum.
2) Shoes smell bad.

The first represents a foundational building block of Western rationalism, the second is a rather banal (albeit true) thought. The first sentence clearly has more meaning, yet they both contain the same amount of information. Why’s that? Because they both have the same number of letters and use the same alphabet (see note). To get ahead of myself slightly, they both contain they same number of bits of information.

The lesson here is that “meaning” and “information” are distinct concepts. Meaning is something which can’t be quantified, whereas information can. Meaning is subjective, information is objective. So how do you quantify information? In bits.

A bit is the fundamental unit of information. It represents the choice between two mutually exclusive things: a one or a zero; a left or a right; a Leche Flan or a chocolate mouse. (on the other hand, maybe I can have both). The choice between two things is said to contain one bit of information. Figuring out how many bits of information a choice contains is essentially a divide and conquer approach: the choice between four things can be broken into two steps of choosing between two groups of things, thus contains two bits of information. The choice between eight things can be broken into three steps of choosing between two groups of things, and so contains three bits of information. This is visually demonstrated below:

As you can see, if you have some number of things to choose from–and that number happens to be a power of two–it is easy to find the number of bits of information that the choice represents: it’s just the power. What happens if your are choosing from some number of things that isn’t a power of 2? Just take the number’s base 2 logarithm. If you don’t know how to do that, don’t worry about it. Just choose the closest power of two. The most you’ll ever be off by is half a bit. Or, just enter log(number)/log(2) into Google. It’ll give you the answer.So back to the two sentences. There are 16 characters in each sentence, including spaces and periods. Each character represents a choice from the English alphabet plus punctuation. Let’s say that there are 32 letters and punctuation marks. That’s 2⁵ things to choose from, so each character represents 5 bits of information. There are 16 characters, so in each sentence there is a total of 5*16 = 80 bits of information.

Choosing any letter (e.g., “g”) is a 5 bit choice.
We’re not even touching the surface of information theory yet, and there are many cool things we could do. For instance, we could compare the number of bits per character in Japanese versus English (it turns out that English is only 60% as compact as Japanese, which explains why Japanese book are always around two-thirds the size of their English counterparts, but I’ll leave that as an exercise for the reader). For now, however, let’s side step and start applying what we’ve learned to interface design.Efficiency

There’s one more thing to get out of the way: the definition of efficiency. Efficiency may seem like a hard thing to quantify, but engineers figured it out a long time ago. You simply divide output by the input.

For a car, the input is gas (which contains a certain amount of chemical energy) and the output is miles driven (kinetic energy). With the appropriate conversion factors, you can divide those two energies to find that your car engine has an efficiency of around 25%. That means you car’s engine is throwing away 3/4 of your gas money by heating the environment instead of making you go forward. An electric car can have efficiencies of upwards of 80%. No wonder the gas companies don’t want Detroit to go electric. But there’s an upper limit to how efficient something can be: 100%. You can’t get more energy out than you put in, otherwise you’d be able to build perpetual motion machines. And that’s something best left to crackpots and politicians.

The most important property of efficiency is that it lets you know how you are doing in the grand scope of things. If an engine has an efficiency of 10%, you know you can do a lot better. And if an engine has an efficiency of 98%, no matter how brilliantly you design, you won’t be able to improve it much.

Efficiency lets you know when you can stop looking for a better design.

The same is true in interface design, where we use a measure called information efficiency. This is simply the minimum amount of information needed for the task divided by the information actually input by the user.

Time for an example.

Digital Wrist Watches

I wrote an article called A Pretty Neat Digital Watch a little bit ago, where I talked about how confusing and inhumane setting a digital watch is. We are now equipped to calculate exactly how bad it is.

To find out how (in)efficient digital watches are to set, we need two pieces of information: how much information is minimally needed, and how much information the user inputs.

Let’s start by figuring out how much information is minimally needed. For simplicity, let’s assume we are only setting time to the minute (so no need to worry about seconds) and that we are ignoring AM/PM considerations.

There are sixty minutes in an hour and twelve hours on a clock. Thus there are 60*12, or 720 possible times to which we can set a watch. 720 is roughly 2^9.5. Therefore, we know that setting the time requires a minimum of 9.5 bits of information.

So far so good. All we need now is to know how much information it takes to set a digital watch.

The buttons of a digital watch.

Digital watches generally have four actions needed to set the time: press SET, press and hold SET, press MODE, and press SPLIT/RESET. That means any one of those actions represents 2 bits of information because there are 4 = 2² choices of actions.Now, to actually set the time, one does:

• Press and hold SET. (1 key press)
• Press MODE to select the hours place. (1 key press)
• Press SPLIT/RESET to advance hours. (6 key presses on average)
• Press MODE to select the minutes place. (1 key press)
• Press SPLIT/RESET to advance minutes. (30 key presses on average).
• Press SET when done. (1 key press)

Counting the key presses yields an average of 40 presses to set a digital watch. Each press represents 2 bits of information, so setting a watch requires 40*2 = 80 bits of information.

Stop to reflect on what that means: setting the time on a digital watch requires the same amount of information as trying to type the sentence “cogito ergo sum”. If someone told you to type that on a watch with only four buttons, you’d tell them they were crazy. Yet you’re doing the equivalent every time you try to set a digital watch.

We can now calculate the efficiency of the setting a digital watch. Remember, the efficiency of an interface is the minimum amount of information needed over the information the user inputs. In this case, 9.5 bits/80 bits, which roughly equals .12, or 12% efficient. We are throwing away almost 90% of our effort.

If you bought a bicycle that was only 12% efficient, you’d return it immediately. With a bicylce like that you’d barely be able to ride along a flat road, let alone attempting a hill.

Analogue Wrist Watches

Digital watches have a lot of room for improvement. Common sense says they’re pretty bad and our calculated efficiency agrees. What can efficiency tell us about analogue watches?

There are two possible actions in setting an analogue watch: choosing whether the watch is in the time-setting mode, and turning the crown to actually set it. The first action represents 1 bit of information (the crown can either be pushed in or pulled out), and the second action represents 9.5 bits of information (there are 720 possible times to which the watch can be set).

Setting an analogue watch requires:

• Pulling out the crown. (1 bit)
• Turning the crown to the right time. (9.5 bits)
• Pushing the crown back in. (1 bit)

In total, 11.5 bits of information is required of the user so the efficiency is 9.5 bits/11.5 bits or 82% efficient. That’s pretty good! Much better than the 12% of the digital watch.

But 82% is still aways from 100%. There should be something we can do to increase the efficiency. The efficiency increase will have to come from pulling or pushing the crown to choose the time-setting mode. What happens if we used a time-setting quasimode instead of a mode? That is, what if we made the crown spring-loaded, so that we would never have to push the crown back in? It would knock-off the final 1 bit of user-input (see note). Thus the efficiency would be 10.5 bits/9.5 bits, or 90% efficient. Of course, one has to be careful to take ergonomics into account: the crown would have to return to it’s original position slowly enough that one wouldn’t have to continually pull the crown out again.

As a short aside, this is a general benefit of using quasimodes: not only does it increase efficiency by eliminating one action, it also decreases mode related errors. Also remeber that efficiency is a single measure: it does not predict how fast a interface is to use, or how easy it is to learn. When designing an interface, optimizing efficiency must be balanced against other considerations.

And now, because we are way up at 90% efficiency, we know that we can stop looking for a better solution.

But one could cheat. If the watch is atomic-clock set, as I described in A Pretty Neat Digital Watch, the user would never have to do a thing, and the efficiency would jump to the vaulted perfection of 100%.

Warning, Warning: Efficiency at 0%

On the other end of the spectrum are those monstrosities of interfaces. The places and devices that require input from the user when no input should be required. These are the times when the computer is simply wasting our time: the second most egregious crime a computer can commit. (The most egregious crime being destroying our work.)

For example, I still come across websites that give me alerts like this:

An error message with 0% efficiency.

This has an efficiency of 0%. There is only one thing that I can do. I can either click “OK”, or wait and click “OK” (or even click the “X”, which does the same thing as clicking “OK”). I have no choice. So the action of clicking doesn’t represent any information. You’d think that such dialog boxes would only appear on web sites circa 1994, but in the latest version of Word, I found this lurking:
A common error message from Word with 0% efficiency.

To all designers out there: please never do this. There’s no excuse.Interfaces with an efficiency of 0% also exist outside the world of poorly designed dialog boxes. There is one in particular that’s so ubiquitous that we use it every time we use a computer.

The Desktop.

Think about it: if you want to write a letter, how much of the letter do you get written on the Desktop? None. If you want to look something up in Wikipedia, how much of the searching do you get done on the Desktop? None. If you want to perform a calculation, how many numbers get crunched on the Desktop? None!

The time you spend fiddling with your Desktop to get where you need to go to get your work done is entirely wasted. You get no work done on the Desktop. It has an efficiency of 0%.

Clearly, there is a lot of room for improvement on the Desktop. A lot. We think we have a solution so keep your eyes peeled next month.

The Shortcomings of Efficiency

Efficiency is a tool that should be included in the arsenal of every designer. It is the only tool that gives a quantitative measure that can compare any given interface to the best possible interface. It’s like magic: you can compare any interface to the best possible interface without knowing what that is!

But, efficiency is not the end-all of interface design. Efficiency doesn’t let you know how fast an interface is, or how often people will make mistakes, or how hard your interface is to learn. The humaneness of an interface simply cannot be reduced to a single number: sometimes highly efficient interfaces can be entirely inhumane. But even a full battery of GOMs modeling, focus groups, and user testing can only show you the mistakes of your current design.

Efficiency can tell you when you need a new inspiration.

---

Note: The careful reader may be waggling their finger at me. It isn’t exactly true that the first and second sentences have exactly the same amount of information. More common letters actually give less information than less common letters. Knowing that a four letter word contains an “e” and a “t” doesn’t give you much help in figuring out what the word is. But knowing that the word contains a “z” and an “m” narrows the choices down a lot. If something is more probable, it contains less information. So if you are a stickler for correctness, pretend that the second sentence was “Go rig outcomes.” (Back)Note: The astute reader may have a burning question at this point: “Doesn’t releasing the crown also yield 1 bit of information?”. The answer is no, but the reason is subtle.

Imagine that your parents are coming over to your place and you want to surprise them by playing their favorite soundtrack. The problem is, you don’t like it very much. You go out and buy the CD but you want to wait until just before they come to start playing it, so you have your friend stand outside and signal you when your parents arrive.

My claim is that your friend’s signal doesn’t convey any information about whether your parents are coming. Why? Because you know your parents are coming. There is no alternative. This isn’t a binary choice between 0 (your parents coming) and 1 (your parents not coming). There is only 0 (your parents coming) and the choice among one thing represents 0 bits of information (2⁰=1).

But your friend giving you a signal clearly contains some sort of information. You know more after his signal, so what’s going on?

The signal isn’t giving you any information about whether your parents are coming, instead it’s giving you information about when your parents are coming. And that’s the subtle, but important, distinction.

If all you care about is if something is going to happen–and it is guaranteed that it will happen–then the fact of when it happens is unimportant. On the other hand, if you do care about when something happens, then even though the fact of it happening doesn’t contain information, the when of it does.

So back in our quasimodal analogue watch. We know that after setting the time the crown will automatically return to the non-pulled state, but we don’t care when it will happen. Because we don’t care about the information conveyed by when, there is no information conveyed by the crown automatically returning. (Back)