I don’t know about you, but when I saw the title GUI Bloopers: Don’ts and Do’s for Software Developers and Web Designers ($44.95, 2000, Morgan Kaufmann Publishers), I thought of the 80s television show TV’s Bloopers and Practical Jokes, hosted by Ed McMahon and Dick Clark. I was young then, but I am fairly certain that I found the show to be very entertaining—probably because I was so young.
This childhood memory influenced my expectations about GUI Bloopers, and I assumed it would be a rather lighthearted (and lightweighted) look at some of the dysfunctional user interfaces that exist in software today. As it turns out, GUI Bloopers is in actuality a complete reference manual for good UI design.
Isn’t Dick Clark hosting?
While I didn’t find GUI Bloopers to be a particularly easy straight-through read, it is organized in such a way that referring back to it for a particular nugget of wisdom is simple. The author, Jeff Johnson, a longtime usability consultant and user interface designer, first lays out eight principles of good UI design. These rules, including such oft-quoted maxims as “Focus on the users and their tasks and not the technology” and “Conform to the users’ view of the task,” seem obvious at first blush. But as Johnson points out, such rules are ignored to such an extent that they need to be stated explicitly. The common theme here is that the software’s user is the most important judge of its interface, and usability testing is a necessity to verify the validity of a design. After introducing his principles, Johnson then reinforces them by drawing upon his wealth of experience and providing examples of UI bloopers, or common design mistakes.
Each chapter relates to a particular family of blooper, like “GUI Component Bloopers” (Chapter 2) and “Responsiveness Bloopers” (Chapter 7). There is also an entire chapter devoted to Web interface design (Chapter 6) and to management bloopers (Chapter 8), a category Johnson created to hold what he considers to be the root environmental causes of most usability problems. The individual chapters are subdivided into sections and subsections examining particular bloopers.
In all, the author shares 82 interface design bloopers, one per section. Each is accompanied by his suggestions for correcting that blooper, along with a reference to the UI guideline that, if applied, would avoid it entirely. Although many of the examples are reproduced from applications Johnson has reviewed as a consultant (with the names changed to protect the guilty), some are taken directly from major commercial applications. Reading about the problems the author has found with the likes of Microsoft Word, Windows, and Qualcomm Eudora will bring a smile to your lips, especially if he’s blasting some design aspect that you’ve found personally annoying.
Oh Eudora, why you do me wrong?
Johnson admits early on that he has a love/hate relationship with the e-mail program Eudora. He’s even composed a short blues song in its honor. It’s fitting, then, that one of the four case study “war stories” that make up the final third of the book chronicles his adventure installing an updated version of Eudora onto his Macintosh. The story of how a simple software installation went badly because of contradictory, sometimes outright wrong, documentation, confusing terminology, and poorly written installation software is comical in a “been there, done that” sort of way.
The other case studies are of the more run-of-the-mill variety: an analysis of Kodak’s PhotoDisk software, the interesting story of the author’s work helping design an innovative UI for the interactive movie video game A Fork in the Tale, and his involvement in the creation of the software for a TV-top satellite box for an anonymous satellite company that sounds a little bit like PrimeStar. Of course, all these case studies refer, when necessary, to earlier sections of the book that elaborate on particular bloopers.
Practicing what you preach
Because GUI Bloopers is a book about usability, and the author obviously takes the matter very seriously, the fact that there is a major problem with the layout of the book is surprising. The copious references to earlier bloopers and design rules are identified by section number, not by page number, requiring you to thumb around a bit before locating the section you are interested in. You could, of course, refer to the table of contents for the correct page number, but in forcing you to take that extra step, the book violates the fourth of Johnson’s own design principles: Don’t complicate the user’s task.
However, that’s really only a minor problem. The value of the practical examples Johnson presents more than makes up for that little annoyance. All in all, GUI Bloopers is an excellent resource and will teach you something new every time you pick it up.
What’s your favorite GUI blooper?
Do you have a particular violation of good GUI common sense that you can’t get out of your mind? Share it with us in an e-mail. Describe the blooper and tell us how you would fix it.