Another principle to keep in mind is that use of conventions not in accord with our natural-language conventions helps make computers feel unfriendly. We must bend the machine to work the way we do rather than change our language conventions to suit what is easiest to program. (p. 113, emphasis in original)
Jef Raskin’s The Humane Interface is part research review, part polemic and part brainstorm. Raskin is most famous as one of the designers of the Apple Macintosh, an acheivement which has earned him permanent guru status in user interface design circles.
The book has lots of crazy, fun ideas. I would like to have seen more new ideas and more crazy ideas — in a world where Microsoft Windows can be considered sane, I need all the insanity I can get. Here are some highlights:
There are also some more palatable ideas that all UI designers should listen to.
Monotony is a fairly frightening idea to some people. Consider most common applications, in which the print function can be accessed in any of three ways: a menu item (File > Print...), a toolbar button, and a hotkey (Command-P). Raskin opines that only one of these three gestures should be used. Especially when combined with modelessness, strict monotony is intriguing.
The usual justification for tying multiple gestures to a single function is that beginners and experts will expect to use the software in different ways. Beginners will need visual cues, such as a large and prominent button on a toolbar, to identify the capabilities of the software. Experts, on the other hand, are likely to turn off the toolbar to optimize the usage of screen real estate, and will take the time to memorize hotkey combinations for speed of execution.
Raskin refutes the idea that software users break into just two degrees of expertise, and instead asserts that habituation is what makes for efficient use of software. (Habituation is the development of “muscle memory” and the ability to execute gestures without conscious thought.) A goal of interface designers should thus be to maximize learnability for new users while at the same time allowing for easy habituation — without requiring experts to learn a whole new set of gestures for speed.
An idea that especially appealed to me was that of authenticating to computer systems using a single token (p. 184). Instead of logging on with the username “chris” and the password “puppydog”, I would tell the computer only “puppydog” and the computer would know that I was Chris. The main hurdle to implementing this convenient feature is that ensuring the uniqueness of each user’s password is inefficient (O(n)).
A related idea is that passwords should be both easy to remember and secure. Conventional wisdom has it that only passwords of ten or more randomly selected characters (including non-alphanumerics) are secure. Expecting the user to think up and then memorize such a password is unreasonable. Instead, Raskin advocates a different scheme:
For example, you can have the computer choose two adjectives and a noun at random from a large dictionary, and present a list such as
- savory manlike oracle
- exclusive malformed seal
- old free papaya
- blooming small labyrinth
- rotten turnip sob story
from which the user can choose her favorite. In English, there are at least two trillion such combinations. (p. 184)
Raskin also discusses the usability of programming environments and how that affects the quality of the software we produce. “Something wonderfully straightforward has been lost: in particular, the immediate feedback that humans need in order to quickly iterate their way to an effective program.” (p. 194) I wouldn’t say that capability has been lost at all; Emacs and Python are just two of the better known interactive programming environments. Note that his humane interface demo project is implemented in Python.
Raskin spends a lot of time on techniques and principles that are only applicable to text editors; for example, on a system without folders or filenames, how will users find their audio, video and image data? You might argue that textual metadata can be attached to such files, but only the most motivated users would put forth the effort required for such a feature to be effective.
A large portion of the book is essentially a paean to the Canon Cat, his old word processor project. He comes off as a crank a lot of the time by failing to address the new demands users put on computers and the new capabilities of computers. A few times I found myself wondering why he doesn’t just come up with a better set of keybindings for Emacs and call it quits. At times it seems like that’s all he really wants.
The guru-istic nature of the discipline and of Raskin himself will inevitably lead to this book being used in appeals to authority. The chapter on “Quantification” notwithstanding, the book doesn’t go into enough quantitative depth. As a literature review, it’s cursory.
Quirks aside, The Humane Interface is an entertaining and easy read, and contains more than a few juicy nuggets and interesting leads for experimentation.