Programming Books C Java PHP Python Learn more Browse Programming Books
Buy Used
$4.30
FREE Shipping on orders over $35.
Condition: Used: Very Good
Access codes and supplements are not guaranteed with used items.
Add to Cart
Have one to sell? Sell on Amazon
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

GUI Bloopers: Don'ts and Do's for Software Developers and Web Designers (Interactive Technologies) Paperback – March 31, 2000

ISBN-13: 978-1558605824 ISBN-10: 1558605827 Edition: 1st

Used
Price: $4.30
21 New from $2.93 63 Used from $0.01 1 Collectible from $9.98
Amazon Price New from Used from
Paperback
"Please retry"
$2.93 $0.01

Free%20Two-Day%20Shipping%20for%20College%20Students%20with%20Amazon%20Student



NO_CONTENT_IN_FEATURE

Shop the New Digital Design Bookstore
Check out the Digital Design Bookstore, a new hub for photographers, art directors, illustrators, web developers, and other creative individuals to find highly rated and highly relevant career resources. Shop books on web development and graphic design, or check out blog posts by authors and thought-leaders in the design industry. Shop now

Product Details

  • 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: 9.2 x 7.3 x 1.3 inches
  • Shipping Weight: 2.2 pounds
  • Average Customer Review: 4.4 out of 5 stars  See all reviews (34 customer reviews)
  • Amazon Best Sellers Rank: #1,607,962 in Books (See Top 100 in Books)

Editorial Reviews

Amazon.com Review

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.

More About the Author

Jeff Johnson is President and Principal Consultant at UI Wizards, Inc., a product usability consulting firm that offers UI design, usability reviews, usability testing, and training (http://www.uiwizards.com). He has worked in the field of Human-Computer Interaction since 1978. After earning B.A. and Ph.D. degrees from Yale and Stanford Universities, he worked as a user-interface designer and implementer, engineer manager, usability tester, and researcher at Cromemco, Xerox, US West, Hewlett-Packard Labs, and Sun Microsystems. At Xerox he worked on successors to Xerox's famed Star workstation. At Sun he worked for the "skunkworks" that produced Java. Jeff has taught at Stanford University and Mills College. He was an Erskine Teaching Fellow at the University of Canterbury in Christchurch New Zealand in 2006 and 2013. He has published numerous articles and book chapters on a variety of topics in Human-Computer Interaction and the impact of technology on society (see http://www.uiwizards.com/portfolio_publications.html). He is a member of the ACM SIGCHI Academy. He frequently gives talks and tutorials at conferences and companies on usability and user-interface design. He is the author of GUI Bloopers: Don'ts and Dos for Software Developers and Web Designers (2000), Web Bloopers: 60 Common Design Mistakes and How to Avoid Them (2003), GUI Bloopers 2.0: Common User Interface Design Don'ts and Dos (2007), Designing with the Mind in Mind (2010), and Conceptual Models: Core to Good Design (2011, co-authored with D. Austin Henderson). A second edition of Designing with the Mind in Mind was published in early 2014.

He is married to Karen Ande, a documentary photographer who works for relief organizations in Africa that support children orphaned by HIV/AIDS, and who is also the author of a book (see http://FaceToFaceAfrica.com).

Customer Reviews

If you are developing or designing GUI applications you must read this book!
eoin
Given the very specific nature of the advice, GUI Bloopers doesn't help much with overall, high-level user interface design.
Michael A Mayo
My only problem was there were many trivial bloopers and many bloopers which may not be bloopers.
James B. Pogue

Most Helpful Customer Reviews

38 of 38 people found the following review helpful By Kevin Barrack VINE VOICE on March 16, 2001
Format: Paperback Verified Purchase
Perhaps this is beside the point, but I was hoping that this book would contain some element of lighthearted humor while discussing such a dry topic. It does not.
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.
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
28 of 28 people found the following review helpful By Thomas Schultz on May 22, 2000
Format: Paperback
This is an indispensable book for anyone involved in the making of software. In 560 pages, Jeff Johnson presents 82 carefully selected examples of mistakes in GUI software and mistakes occuring in the process of developing GUI software (a GUI Blooper). Instead of just pointing his fingers at the Bloopers which are listed, Mr. Johnson provides a VERY exhaustive walk-through of the mistakes including: Why is this a mistake, what category does it belong to, what could be done to remedy the situation (including examples), common reasons for committing this mistake. As extras, two case stories from Mr. Johnsons career as an UI consultant are provided together with some general remarks on user centred development. My favorite chapter of the book contains examples on GUI mistakes wich are due to poor management. This chapter ought to be required reading for any software manager. The Bloopers are grouped in seven chapters: GUI Component Bloopers; Layout Bloopers; Textual Bloopers; Interaction Bloopers; Web Bloopers; Responsiveness Bloopers; Man-agement Bloopers. This grouping combined with a very extensive index makes this book ideal for reference purposes. The layout of the book is simple and clear - some may say boring. There are a number of drawings with examples of remakes of GUI elements which, although effective, are somewhat poor. For dictionary purposes this book may rightly deserve 5 stars. But due to the fact this book is overly wordy (I would say that 20% of the text is superfluous) and due to a somewhat content weak chapter on Web Bloopers, it will have to do with just four stars.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
22 of 22 people found the following review helpful By Bob Carpenter on August 19, 2001
Format: Paperback Verified Purchase
Despite the title, the "Do's" section of this book is where the meat lies. The "bloopers" are used as lead-ins on how to design interfaces with a focus on usability. If you're even contemplating designing anything from a web page to an installation shield, you should read this book. Customers should read this book, and managers should read this book. The book's really not aimed at programmers or graphic designers, but they'll find it plenty interesting, especially since programmers and graphic designers often design GUIs.
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_.
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Customer Images

Most Recent Customer Reviews

Search