Interface inertia
Raskin discusses the speed of human–computer interaction in detail, covering Hick’s and Fitts’s laws. The author has a few new thoughts on the subject, and this article is about them.
The idea was prompted by a small but painful change in the design of iOS 5, the latest version of the iPhone software at the time of writing. For perfectly logical reasons, Apple decided to add a button that takes you to its music store straight from the music player. No sooner said than done. And here is how they did it:
The catch is that the problem with this button shows up only dynamically, while you are using the app, and is completely invisible statically, when you simply look at the screen. In the list of songs of the selected album, the place of the Store button is taken by another button, Albums, which takes the user back to the first screen with the list of albums.
There is a third button in the same spot, on the Now Playing screen, which also takes you one step back, to the album’s song list.
So when using the player quickly, the user may accidentally press “Back” twice when only one press is needed. The finger then lands on the Store button, and the player switches to the store app, leaving the user puzzled and frantically looking for a way back to their music.
Since this mistake is made by inertia, we will call our law the law of inertia.
The typing problem
The law of inertia is not limited to a single example. It is everywhere.
The biggest problem appears when typing. Many experienced users are used to doing several things at once. The author often installs programs or updates while chatting with someone or writing a new article.
The trouble is that under certain conditions, an installer may suddenly demand the user’s attention and pop up its window on top of all others. If the user is typing at that moment, the input focus jumps to the new window, and the typing continues there. Worse, if the user presses Space or Return, this may trigger the active button in the window and confirm or cancel some action of the installer. That can lead to unpredictable and sometimes very serious consequences.
One solution is to stop the space bar from pressing buttons. This would reduce the chance of unintended actions, but it would not solve every problem and would take away keyboard control.
Another option is to rework the OS notification mechanism so that windows cannot pop up at all, or can do so only sometimes, or only in a non-obvious way. Notifications would then be limited to flashing, bouncing or other animation in the taskbar or the Dock.
The best solution, in the author’s opinion, is to detect fast typing and postpone the appearance of other windows until the typing stops. There is still a chance that focus will jump to the new window if, after the delay, it appears just as the user starts typing again. So, where possible, a combination of this and the previous method should be used.
The changing interface problem
An equally serious flaw is interface elements that change suddenly.
One of the most striking examples is Safari on the iPhone. To save space, browsers often combine the Reload and Stop buttons. While the page is loading, the Stop button is active; once the page has loaded, the Reload button appears in its place.
The problem is that the user may decide to stop loading at the very last moment, just as loading completes and the buttons switch. The finger starts moving while Stop is active, but the tap lands on Reload. As a result, the page starts reloading.
This is one of the clearest examples of inertia in interfaces. The author has run into it many times and is sure he is not alone.
One solution is to delay the button switch for a while after loading completes.
Something similar happens on desktop computers. In installers, for example, the user often has to click Next, and sometimes does so on autopilot without reading the instructions. This is unlikely to have fatal consequences, but in general, inertia can make you perform an unintended action if some other button suddenly appears where Next used to be.
The warning problem
The third type of problem occurs in warning and confirmation dialogs. When working fast, the user may click the first button that comes along in a dialog that has just popped up. The button, however, is not chosen entirely at random. Two factors come into play: the standard, familiar position of the confirm button in a particular program, and the length, complexity and readability of its label.
In other words, if the OS always places Yes to the right of No, the user develops a habit of clicking the right-hand button automatically. If you swap the buttons and replace the short labels Yes and No with Confirm Deletion and Cancel Deletion, this breaks the habit and makes the user read the text and think about the choice.
Another good solution comes from the makers of Firefox. When you install a plugin, the browser asks for confirmation, but the Install button becomes available only after a few seconds.
Measuring interface inertia
Let’s try to formalize these observations and derive a method for estimating how prone an interface is to inertia.
Clearly, the probability of performing an action by inertia depends on:
- The pace of operations that can trigger an unintended action.
- How quickly, or suddenly, the unintended action appears.
- The user’s reaction time, taking their focus of attention into account.
Let the first user type at 360 characters per minute, or 6 characters per second. The first user touch-types, and their reaction time is 1 second.
Let the second user type at 120 characters per minute, or 2 characters per second. The second user does not touch-type, and their reaction time is 5 seconds.
Let the dangerous key be the space bar. The probability of a space in English text is 0.2. So the first user presses the space bar on average 72 times per minute, or 1.2 times per second, and the second user 24 times per minute, or 0.4 times per second.
Let’s calculate the interface inertia when a “dangerous” element (in our case, one that can be activated with the space bar) appears with no delay. We propose the following formula for interface inertia:
For the first user:
For the second user:
Now let’s calculate the inertia with a delay equal to the reaction time.
For the first user:
For the second user:
And finally, with a delay twice as long as the reaction time.
For the first user:
For the second user:
Clearly, the longer the delay, the lower the interface inertia. With a delay equal to the reaction time, the inertia is zero. With a shorter delay, the inertia is positive; with a longer one, it is negative, meaning our “brake” kicks in with a margin.
Note that the delay cannot be too long. Otherwise the interface will simply be blocked, and the user will have to wait until it unlocks.
The author considers it reasonable to choose a delay that keeps the inertia between −1 and 0.