GUI Bloopers: Don'ts and Do's for Software Developers and Web Designers (Interactive Technologies) | 
 enlarge | Author: Jeff Johnson
Publisher: Morgan Kaufmann
Category: Book
List Price: $63.95
Buy Used: $5.39
You Save: $58.56 (92%)
New (12) Used (16) from $5.39
Avg. Customer Rating:  34 reviews
Sales Rank: 384781
Media: Paperback
Edition: 1st
Number Of Items: 1
Pages: 584
Shipping Weight (lbs): 2.3
Dimensions (in): 8.9 x 7.3 x 1.3
ISBN: 1558605827
Dewey Decimal Number: 005.437
EAN: 9781558605824
ASIN: 1558605827
Publication Date: March 17, 2000
Availability: Usually ships in 1-2 business days
Shipping: Expedited shipping available
Condition: The book is clean but may have highlights.
|
| Editorial Reviews:
Amazon.com
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
Product Description
GUI Bloopers looks at user interface design bloopers from commercial software, Web sites, and information appliances, explaining how intelligent, well-intentioned professionals made these dreadful mistakes--and how you can avoid them. While equipping you with all the theory needed to learn from these examples, GUI expert Jeff Johnson also presents the reality of interface design in an entertaining, anecdotal, and instructive way.
This is an excellent, well-illustrated resource for anyone whose work touches on usability issues, including software engineers, Web site designers, managers of development processes, QA professionals, and usability professionals.
Hear Jeff Johnson's interview podcast on software and website usability at the University of Canterbury (25 min.)
* Takes a learn-by-example approach that teaches you to avoid common errors by asking the appropriate questions of your own interface designs.
* Includes two complete war stories, drawn from the author's personal experience, that describe in detail the challenges faced by UI engineers.
* Covers bloopers in a wide range of categories: GUI components, layout and appearance, text messages, interaction strategies, Web site design, responsiveness issues, management decision-making, and even more at www.GUI-bloopers.com.
* Organized and formatted based on the results of its own usability testing--so you can quickly find the information you need, packaged in easily digested pieces.
*Announcing the sequel: Web Bloopers. Totally devoted to the Web. Go to www.web-bloopers.com.
|
| Customer Reviews: Read 29 more reviews...
 Excellent Reference for Designers & Developers September 11, 2007
If you are a designer who has to explain to developers what they are doing wrong, get this book (or maybe the next edition, out soon). I loved this book for how well it explained every bad interface design blooper I had ever seen at that point & helped me understand why developers created many of these problems. It helped me explain to developers why there were better solutions & how to design them. It also contains an excellent introduction to user-centered design. It's a very well organized and valuable reference for interface designers & a great gift for any open-minded developer interested in good UI design. I'm looking forward to his next edition.
Great book to get started on UI design September 7, 2006
1 out of 1 found this review helpful
This was my first book on user interface design, and it was a great choice. It gives good information on principles and also provides specific usable information for how to use controls, etc. I found the organization of the book easy to use and enjoyed reading it.
 Good book, still useful September 28, 2005
4 out of 4 found this review helpful
The author of this book does a very good job of describing and illustrating common GUI design mistakes. He has categorized the problems in broad topics such as "GUI Component Bloopers" and "Interaction Bloopers", then gives concrete examples of the bloopers that occur within each broad topic. The individual bloopers are well illustrated, and examples of better approaches are given.
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.
 Too old July 25, 2005
3 out of 22 found this review helpful
Don't buy this book, it refers to applications written in early '90. Today it is completely a different story.
Excellent text for my GUI programming class July 9, 2005
8 out of 8 found this review helpful
I am a professor of computer science who offers a two-semester, senior capstone project experience in GUI programming. I have taught this course using a variety of languages and tools, and I have always found that the programming gets in the way of the principles. I have long sought a book that focuses just on the principles and around which I could sequence my lectures. GUI Bloopers fits that requirement like a glove. I use this as the primary text in my classes and supplement it with various books that supply the information needed to implement actual programs in Java and Swing. (We look at .NET, too, but the main programming environment at this time is Java.)
Contrary to some other reviewers, I find GUI Bloopers very enjoyable to read. In addition, I find that it is not at all too elementary for my students, even the first few chapters. It's amazing how many senior computer science majors don't really understand, for example, the difference between radio buttons and checkboxes, even though they use them all the time. One can't take such understanding for granted. Familiarity with a component is not the same as true knowledge of how that component is intended to be used and what users expect to happen when they interact with it. Johnson's constant reminders to test user interfaces on real users, and his discussion of the various levels of usability testing in simple terms, are invaluable lessons. The illustrations and tales from the author's consulting practice bring the principles down to earth and drive home their points effectively.
I highly recommend GUI Bloopers as a college text.
|
|
|
