- Series: Interactive Technologies
- Paperback: 576 pages
- Publisher: Morgan Kaufmann; 1 edition (March 31, 2000)
- Language: English
- ISBN-10: 1558605827
- ISBN-13: 978-1558605824
- Product Dimensions: 7.5 x 1.2 x 9.5 inches
- Shipping Weight: 2.2 pounds
- Average Customer Review: 31 customer reviews
- Amazon Best Sellers Rank: #2,765,835 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
GUI Bloopers: Don'ts and Do's for Software Developers and Web Designers (Interactive Technologies) 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
There is a newer edition of this item:
Customers who viewed this item also viewed
Customers who bought this item also bought
In GUI Bloopers, consultant Jeff Johnson uses 550+ pages to illustrate common pitfalls in user interface design, the all-important iceberg tip that end users confuse with applications and that developers confuse with end users. Reporting on 82 incidents of bad design, Johnson manages to cover the essential point of his message: software designers should think of their user interfaces from the user's point of view. Not profound, but profoundly overlooked in most low-end to mid-range development efforts. His codification of GUI design in eight predictable principles will help GUI newbies realize that the customer must be pleased with the product. Of course, the customer doesn't always understand what he or she wants. Hence, GUI development is iterative. When the customer is not at hand, a surrogate will do, so usability testing is essential.
The bloopers include mistakes in window design, labeling consistency, visual/grammatical parallel construction, coherence of look and feel, and clarity. Most perceptively, Johnson observes that CPU speed in the development group hides many design mistakes. Moreover, context-scoping, already a subtle problem in software design, must be implemented in GUI design. Input error handling is the most psychologically sensitive of all GUI design characteristics. User error messages can easily be too vague or too specific, and diagnostic error messages should be user-manageable, if not actually user-interpretable.
Like the Hollywood outtakes that gave us the "blooper," the entertainment quotient here is measured in mistakes, not successes. Teaching by counter example rather than by example at an estimated ratio of three to one, Johnson panders to our invertebrate instinct to measure our own successes by someone else's failure. To his credit, he recognizes that user interfaces include pedestrian texts (like his) as well as graphical interfaces for computer applications. His self-referential style gives the book an egocentric slant, but he is both priest and practitioner: he submitted a draft to usability testers and reports the results in an appendix. One criticism was that there were too many negative examples. Hmmm.
Thanks to other tester comments, GUI Bloopers is a browsable book, allowing the few nuggets of wisdom to be located. For the most part, the book's value can be captured by reading the seven-page table of contents carefully. --Peter Leopold
From Library Journal
GUI stands for graphical user interface. Bloopers are incredibly dumb designs created over the past ten years such as error messages, unreadable fonts, hidden functionality, installation nightmares, back buttons that don't go back, and untimely feedback. Highlighting those and other (82 total) examples of bad design, Johnson, president and primary consultant at UI a Wizards Inc., believes software designers should design from the user's point of view. Readers will find his chapter on good design principles useful; recommended for university and large public libraries.
Copyright 2000 Reed Business Information, Inc.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
Johnson gives us a widget-by-widget tour of labels, text fields, buttons, radio buttons, check boxes, and overall layout management. But he doesn't stop there. The notion of usability also extends into issues like consistency. Even more important is responsiveness, the chapter on which is worth the price of the book alone.
What makes this book so enjoyable is the multitude of case studies. These aren't meant to make you laugh out loud like Lucille-Ball-botching-her-line bloopers, but rather to get you to concentrate on the bigger picture of usability. The longer case studies of Johnson's experience as a consultant on a set-top-box design project and a game interface project are interesting if you're thinking about working with or becoming an interface design consultant yourself.
Another benefit of the book is that it takes you through common and common sensical design strategies starting from needs analysis to paper prototyping to early focus group testing and refinement. The references to deeper studies in many of these areas are plentiful.
This book is more focused on GUIs than books like Ben Schneiderman's _Designing the User Interface_, which is a useful, thoughtful survey, but reads like a Ph.D. thesis compared to _GUI Bloopers_. Johnson is also focused on usability, in contrast to something like the _Java Look and Feel Design Guidelines_, which focuses exclusively on graphical layout issues, such as how many pixels to leave around 9 point sans serif font in a button and what color scheme to use for highlighted icons.
One final note: Johnson ate his own dog food and usability tested his book!
Even though the applications used in the book are from the nineties, they are still very applicable, since the advice given frequently transcends the tools used to build the screens. It is applicable to web applications as well.
I read through this book once, and now use it as a reference.
The introduction states explicitly that the book is not intending to discuss either UI examples that are the most flagrantly hilarious, or examples that are the worst. Rather, the book critiques UI examples that are some of the most common. The examples are good, and described in depth, with specific reasons given for their classification as mistakes. There are also suggestions in some cases for how the designers could have avoided the blooper.
As a visual designer working primarily on the Web, I found this book as a good place to start learning more about the basics of an analytical approach to User Interface design. Even though the book focusses mostly on stand-alone application design, the principles can still be applied to UI issues on the Web, certainly in Web design using forms or heavy information structure. Some examples are hard to apply to the Web, for instance, the bloopers dealing with application menubar design issues are not widely applicable to Web pages. However, this book provides a great overview of the philosophy and process of UI design.
The worst thing I can say about this book, is that it isn't any fun to read, despite the impression given by the title. Since I come from a less analytical perspective on the topic, it definitely takes some determination to read this, although it is written in a straightforward and accessible manner. The most annoying aspect of the writing is that Jeff Johnson has apparently developed some bitterness towards everyone who is not a UI professional, and he rants constantly about developers, designers, marketing, and management. While his reasoning is usually valid, many entries read like the author is venting his issues to his psychiatrist after a hard week of consulting. With all the jaded complaining about developers (who seem to be his favorite target), I can't believe any of them can tolerate reading this book.
If you can get past Jeff Johnson's fanatical personality then there is much good insight to be gained from this book, for all User Interface novices.
I was at the session at the Computer Human Interaction conference in Holland where Jeff Johnson spoke. But another Jeff, Jeff Raskin also spoke and showed how some of Johnson's examples could be improved.
Raskin also introduced a book, The Humane Interface, somewhat deeper than this one, that helps you to really understand Web design. I'd reccomend reading and understanding Raskin's book so that you can see the few places where Johnson's ideas don't quite work. Then you can use this book, which is 95% right.
Most recent customer reviews
The first chapter or so describes some very basic GUI problems - eg.Read more