Book Review: GUI Bloopers 2.0

Book | Author | Review

By Gerd Waloszek, SAP User Experience, SAP AG – November 13, 2008 • original article (book review in Books&People)

This review takes a personal look at Jeff Johnson's book GUI Bloopers 2.0.

 

Book

Cover of GUI Bloopers 2.0     

Jeff Johnson
GUI Bloopers 2.0: Common User Interface Design Don'ts and Dos
Morgan Kaufmann, 2007
ISBN: 0123706432

Usability: UI Design

 

Author

Photo of Jeff JohnsonJeff Johnson is a consultant at UI Wizards, Inc., a product usability firm (www.uiwizards.com). He has worked in the field of human-computer interaction since 1978 as a software designer, usability tester, manager, and researcher. Besides GUI Bloopers 2.0, the original version of the book from 2000, and his Web Bloopers book, Jeff Johnson has written numerous articles and book chapters on aspects of topics human-computer interaction and the impact of technology on society. (From book cover and GUI Bloopers tutorial, modified)

 

Review

Seven years after the original publication of his famous GUI Bloopers book, Jeff Johnson published the second edition, GUI Bloopers 2.0, announcing on the cover that it has been "totally updated and revised." Of course, "updated and revised" points to the fact that the essentials of the book have remained unchanged – and that is a good thing, because GUI Bloopers was already a useful book in its first edition. However, a number of reasons led Johnson to eventually publish a new edition of his book, as is explained in the introduction to his book:

  • First and probably most important, the book had started to look out of date because of the many "real-world" examples it included (for example, Mac OS9 screens).
  • Some bloopers have become less common, while others and new bloopers have taken their place. To reflect recent trends, Johnson has included more bloopers found in Web applications.
  • Johnson also observed that over the years he has developed better ways to explain and avoid bloopers and also has gained a clearer understanding of basic UI design principles. Readers of a new edition of his book can profit from his new insight.
  • Furthermore, the author made improvements to the book based on the feedback that he received from readers of the first edition (details can be found in appendix B of the book). For example, he has added figure captions – a curious omission in the first edition.

Johnson lists his intended target audience of the book, in the order of priority, as follows:

  • Developers who develop software or Websites with little or no guidance or feedback from UI professionals
  • Managers of software development teams
  • UI designers, especially those who are new to the profession

As these three groups have different goals and objectives, Johnson provides reading directions for each of them, including a summary table for the hurried. According to this table, managers are allowed to skip large parts of the book, while UI designers are allowed to skim through a number of blooper chapters. Only GUI programmers are requested to dig deeper into the book. All in all, these recommendations make a lot of sense and reflect Johnson's practical orientation.

What is a Blooper?

Now it is overdue to ask what a blooper is. According to Johnson, bloopers are "howlers," that is, design mistakes that are simply amazing. But that is not sufficient for an error to be called a "blooper": Johnson states that bloopers are "mistakes that developers make over and over and over again," so they have to be common. He also points out that it is not his intention to embarrass developers and cause readers to laugh – his aim is to help UI designers and developers learn to produce better user interfaces.

While there are learning theories claiming that people should learn from positive examples only, practitioners like Johnson often take the opposite route and prefer to present examples of what to avoid. Johnson, too, follows the second approach but does not leave it at that. He describes bloopers, illustrates them using real or made up screen images, tells stories from his own experience, and accompanies them with a design rule that helps developers avoid them. These rules are often illustrated, and many include negative as well as positive examples, again real or made up. For easy scanning, examples are also marked with a "thumbs down" or "thumbs up" symbol. Johnson remarks that only very few of the examples relate to his own consulting activities in order not to embarrass any of his clients.

Walkthrough of the Book

The book starts with introduction, telling the purpose of the book, what bloopers are and who the target audience is. Next comes a chapter called "First principles," which introduces nine basic UI design principles that help to create a common understanding of what Johnson regards as the key concepts of user-centered user interface design. The following chapters represent the main section of the book and describe seven bloopers categories. The book concludes with a number of useful appendices.

The real starting point of the book is the chapter about basic or "first" design principles, such as "Focus on the users' and their tasks, not on technology." You will find a complete list of the first principles in the appendix of this review. This explanatory chapter was already in the first edition of the book at the request of programmers who wanted some explanations before they delved into the bloopers. Interestingly, in his reading recommendations for GUI programmers Johnson declares this chapter to be "optional." Personally, I find this chapter an essential element of the book and particularly the first two principles (Focus on the users and their tasks, not on technology; Consider function first, presentation later) served as a welcome refresher of my UI process knowledge. All in all, other authors might formulate the basic principles somewhat differently and add or omit some of them, but as they stand, they provide a good understanding of what user-centered UI design is about.

As already indicated, the following seven chapters form the "core" of the book and are devoted to the GUI bloopers. Johnson lists 70 bloopers, describing and accompanying them with explanations of how to avoid them. Each chapter is devoted to a specific category, such as GUI control bloopers, textual bloopers, or interaction bloopers. See the appendix for the blooper categories and the numbers of bloopers in each category. It would definitely have been useful to offer a compact list of all the bloopers with this review, but for copyright reasons I cannot make such a list available here. However, on the book Web site www.gui-bloopers.com, Johnson offers a blooper checklist and a checklist in PDF format for download. The Website also provides two color bloopers, which could not be included in the book because it is printed in black-and-white.

When reading the different blooper chapters, I was often reminded of design issues that I had encountered during the years when I consulted for enterprise and Web applications at SAP. Johnson found a truly relevant selection of bloopers that are grounded in daily UI design practice. In my opinion, two blooper chapters stand out from the crowd because they cover topics that are rarely dealt with in UI design books. First, the chapter "Management Bloopers" is devoted to issues that are related to improper management. They are divided into the two aspects of counterproductive attitude and processes. When dealing with the latter, Johnson also discusses how AJAX/Scrum and user-centered design fit together.

The most important chapter for me, however, was the chapter covering responsiveness bloopers (plus the respective principles in the second chapter). This is due to the fact that I am currently involved in a project addressing perceived performance, where responsiveness is one of the major issues. To my knowledge, Johnson's book is the only one that covers this topic adequately and intensively. (I found some information in Cooper et al. About Face 3.0 and in Shneiderman & Plaisant Designing the User Interface). Thus, for me the book (as well as its previous edition) has turned out to be a "life saver." In am confident that other UI professionals will also find "their" blooper chapter or chapters in the book. The responsiveness chapter also stands out because its structure differs from that of other chapters. However, I found that this causes some textual redundancies.

Developers in particular asked Johnson to make the seven blooper chapters as "random accessible" as possible. As I read the book from cover to cover (with the exception of the responsiveness bloopers chapter), I cannot confirm whether he succeeded in doing so. At least for the responsiveness chapter this seems to be the case.

Finally, the appendices offer a number of useful additions, such as a glossary, information on how the book was usability tested, some further information on task action analysis, the object/action matrix, and usability tests, a bibliography, and an index.

Conclusions

Johnson succeeded in making an already useful book even more useful. By publishing a second edition he also prevented his book from looking outdated, which might have scared away some readers who might have had the impression that the book is no longer relevant. In its new form, with all the adaptations to the changes in the UI world – particularly the rise of the Web – the book has indeed sustained its relevance and should be a mandatory addition to any library of UI books. Johnson's target audience should probably even keep one on their desks. If I had to recommend only three books to a new UI designer or a GUI developer, Johnson's GUI Bloopers 2.0 would definitely be one of them. (I am still thinking about the other two. For people who want an overview of the UI field, Shneiderman's & Plaisant's Designing the User Interface would be one of them.) It really provides the design basics, process knowledge in a nutshell and, most importantly, promotes the right attitude towards user-centered design. Moreover, the book is easy and often fun to read.

Nevertheless, I do not regard the book as perfect in every aspect. The first edition of the book was criticized for being too wordy. As you can see in the appendix further down, Johnson took this criticism seriously and reduced the number of pages considerably. For my personal taste, however, the book is still too verbose. Furthermore, readers asked for more examples, which Johnson provides. However, as I am not a beginner, I often find examples boring and easily fall into to habit of skipping them. Moreover, most of the "real" blooper examples have probably been corrected in the meantime, anyway.

All in all, I award a definite "thumbs up" to the book and recommend it not only to the target audience. I also recommend it to experienced UI designers as a refresher and quick and dirty reference for UI design traps that should be avoided. It may also help them to give useful advice to new colleagues in their companies.

 

Appendices

Some Differences Between the First and the Second Edition

First Edition Second Edition Changes, Comments
# of Pages
560
407
Second edition has about 150 pages less, but is not much thinner..
# of Pages: First Principles and Bloopers
491
372
Second edition contains about 120 pages less for principles and bloopers than first edition
Further Differences Contains chapters Software Reviews, War Stories of a User Interface Consultant Appendix extended Two chapters from the first edition were left out in the second editions, the appendix has been extended in second edition
# of First Principles
8
9
One first principle has been split into two in the second edition: Don't complicate the users' task -> (1) Design for the common case, (2) Don't distract users from their goals
# of Blooper Categories
7
7

One category exchanged for another: Web bloopers -> navigation bloopers

Bloopers within categories newly arranged in the second edition

# of Bloopers
75
70

2 color bloopers on Website www.gui-bloopers.com

Several bloopers omitted and new ones added in the second edition

Basic Design Principles

  1. Focus on the users and their tasks, not on technology
  2. Consider function first, presentation later
  3. Conform to the users' view of the task
  4. Design for the common case *
  5. Don't distract users from their goals *
  6. Facilitate learning (was: Promote learning)
  7. Deliver information, not just data
  8. Design for responsiveness
  9. Try it out on users, then fix it!

*) Were originally combined to form principle "Don't complicate the users' task" in the first edition

Blooper Categories

The book lists 70 bloopers subsumed under seven topics (listed with subtopics):

  • GUI control bloopers (1-12=12)
    Using the wrong control, using controls wrongly
  • Navigation bloopers (13-21=9)
    Not showing users where they are, leading users astray and not showing the way, poor search navigation
  • Textual bloopers (22-31=10)
    Uncommunicative text, developer-centric text, misleading text
  • Graphic design and layout bloopers (32-39=8)
    Bad layout and window placement, troublesome typography
  • Interaction bloopers (40-51=12)
    Deviating from task focus, requiring unnecessary steps, burdening users' memory, taking control away from users
  • Responsiveness bloopers (52-63=12)
  • Management bloopers (64-70=7)
    Counterproductive attitude, counterproductive processes

New category: Navigation bloopers
Eliminated category: Web bloopers

See also Web Bloopers, Jeff Johnson's previous book, with a review. Read the review of the first edition of GUI Bloopers.

 

top top