Have one to sell? Sell yours here
Sorry, this item is not available in
Image not available for
Image not available

Tell the Publisher!
Id like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

GUI Bloopers: Don'ts and Do's for Software Developers and Web Designers (Interactive Technologies) [Paperback]

Jeff Johnson
4.0 out of 5 stars  See all reviews (4 customer reviews)

Available from these sellers.

There is a newer edition of this item:
GUI Bloopers 2.0: Common User Interface Design Don'ts and Dos (Interactive Technologies) GUI Bloopers 2.0: Common User Interface Design Don'ts and Dos (Interactive Technologies) 5.0 out of 5 stars (1)
In stock.

Book Description

14 April 2000 Interactive Technologies
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.

Customers Who Viewed This Item Also Viewed

Product details

  • Paperback: 576 pages
  • Publisher: Morgan Kaufmann (14 April 2000)
  • Language: English
  • ISBN-10: 1558605827
  • ISBN-13: 978-1558605824
  • Product Dimensions: 23.4 x 18.5 x 3.3 cm
  • Average Customer Review: 4.0 out of 5 stars  See all reviews (4 customer reviews)
  • Amazon Bestsellers Rank: 1,206,330 in Books (See Top 100 in Books)
  • See Complete Table of Contents

More About the Author

Discover books, learn about writers, and more.

Product Description

Amazon 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 newcomers realise 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, labelling 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 out-takes 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 3:1, Johnson panders to our invertebrate instinct to measure our own successes by someone else's failure. To his credit, he recognises 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 as an appendix. One criticism was of 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


"Better read this book, or your design will be featured in Bloopers II. Seriously, bloopers may be fun in Hollywood outtakes, but no movie director would include them in the final film. So why do we find so many bloopers in shipped software? Follow Jeff Johnson as he leads the blooper patrol deep into enemy territory: he takes no prisoners but reveals all the design stupidities that users have been cursing over the years."
—Jakob Nielsen, Usability Guru, Nielsen Norman Group

"If you are a software developer, read this book, especially if you don't think you need it. Don't worry, it isn't filled with abstract and useless theory--this is a book for doers, code writers, and those in the front trenches. Buy it, read it, and take two sections daily."
—Don Norman, President, UNext Learning Systems

Inside This Book (Learn More)
First Sentence
"I wish! Alas, many others have stated this principle before me, and it doesn't seem to have done much good." Read the first page
Explore More
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index | Back Cover
Search inside this book:

Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

4 star
2 star
1 star
4.0 out of 5 stars
4.0 out of 5 stars
Most Helpful Customer Reviews
13 of 13 people found the following review helpful
Format:Paperback|Verified Purchase
Jeff Johnson is an enthusiast about his subject. Through this book he is disseminating years of accumulated wisdom and anecdotes about interface design and (for the greater part) what is wrong with modern systems.
Unfortunately the book is betraying that he's a bit too close to the coal face to have a wider influence than his own team or client base. What I mean by that; Johnson has understood the fundamentals of good vs bad in interface design, and is presenting fairly explanatory examples. He then goes and spoils it by far too much nit-picking analysis and constant flawed analogies to non-IT tasks. The book also spends over 300 pages slinging mud at, mostly, three or four apps ... it transpires later on that one of these is probably there because the author had a run in with a certain MD. It does get a bit tiresome to read yet another 3 page diatribe about the same form in the same app for a slightly different infraction of GUI design.
Now I am not dismissing the substance here, the points he has made are valid and helpful, just not vastly readable. This means a book that is supposed to be a manifesto for a better future with our computers, comes across more like a lab report from hell. Maybe the best way to approach this is to use the first 7 chapters as reference only. The book is remarkably well categorised and indexed, and so is perfectly suited to quickly providing a reasoned answer when one is, say, wrangling over whether a set of buttons would be better than a list or combo.
Unlike Cooper (Inmates are running the Asylum), Johnson presents very well balanced interpretations of the failings which result in poor interface design. The essay towards the end (Management bloopers) is the 100 pages I refer to in my title ... that should be compulsary reading for everyone.
Read more ›
Comment | 
Was this review helpful to you?
21 of 23 people found the following review helpful
By A Customer
This book will help all GUI designers, and especially novices, to be aware of the no-no's of UI design without having to wade through all the theory books. It is immediately useful and accessible to GUI programmers who don't have time for HCI. For people such as me who are involved in reviewing a user interface design this book is chocked full of examples that help us explain what is wrong with the GUI we are reviewing. For managers (of people like me who complain about bad GUI's) this book contains a very good section on the most common problems of (mis)managing the UI design process. All round this book is essential reading for anyone involved in design User Interfaces.
Comment | 
Was this review helpful to you?
1 of 1 people found the following review helpful
5.0 out of 5 stars Invaluable 9 Feb 2006
As the lead developer of a full web application (MicroAid) I found this book absolutely invaluable.
It's the hundreds of simple tips that make it good - where to put radio button groups, how to label fields properly. It amazed me how many bloopers we'd made over the years without realising it. And so simple to put right.
Comment | 
Was this review helpful to you?
3 of 6 people found the following review helpful
3.0 out of 5 stars GUI's without pictures 22 Oct 2003
Call me crazy, but being a designer, I like books for designers to be 1. in colour, 2. have pictures (not dodgy clip art cartoons every 50 pages or so) 3. get to the point, less text more examples.
Don't get me wrong. If you like reading phone book sized text heavy, graphicless books, you'll love this. But for me, I prefer to see design by example, not by "words".
Comment | 
Was this review helpful to you?
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com: 4.4 out of 5 stars  34 reviews
38 of 38 people found the following review helpful
4.0 out of 5 stars Useful but Not Fun to Read (Graphic Design Perspective) 16 Mar 2001
By Kevin Barrack - Published on Amazon.com
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. 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.
28 of 28 people found the following review helpful
4.0 out of 5 stars A perfect companion for "official" user interface guidelines 22 May 2000
By Thomas Schultz - Published on Amazon.com
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.
22 of 22 people found the following review helpful
5.0 out of 5 stars A complete how-to for GUI designers. 19 Aug 2001
By Bob Carpenter - Published on Amazon.com
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_. 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!
14 of 14 people found the following review helpful
5.0 out of 5 stars Most practical UI book I have read - excellent organisation 10 Mar 2001
By Daniel Moth - Published on Amazon.com
If your introduction to HCI was through one of the usual books by Hix, Dix, Schneiderman, Preece etc this book will come as a breath of fresh air. Unlike other books on the subject, this one is not academic and in fact it has one of the most practical approaches I have come across. Not groundbreaking like "About Face", but certainly more useful to everyday developers.
After going through the theory in the first chapter, the author lists 82 GUI bloopers organised in logical sections, grouped under 7 chapters - thus making the book easily searchable. At first you might think that the book provides a few laughs at the expense of GUI screen shots from software applications publicly available. It certainly does that and it is very entertaining from that point of view, but that is just a side effect of the real value it offers.
Every blooper is described in terms of why it is wrong, accompanied with screen shot examples and reasons why a developer might have committed the mistake. It finishes off by describing the remedy to the blooper and providing GUI solutions for the screenshots that were 'named and shamed' earlier. The approach is very instructive but not overbearing.
Categories include GUI components, layout & appearance, textual, interaction and responsiveness bloopers. Believe me: these are not extreme GUI errors that we never commit; read this book and prepare to be enlightened. It has earned a place on my reference shelf and I am already referring back to it every now and then. We are also using it as a checklist for UI products in Alpha/Beta development and for assisting in the production of a new in-house style guide.
13 of 13 people found the following review helpful
5.0 out of 5 stars Excellent advice; This book needed to be written 17 Jan 2001
By Michael A Mayo - Published on Amazon.com
GUI Bloopers details a set of very specific ways developers commonly misuse specific GUI elements. Most of the bloopers are "minor" mistakes that are easy to make. For example, incorrectly "greying out" inactive controls and using text fields to display text that isn't editable. However, Jeff Johnson makes a powerfull case that these "minor" errors can have a major effect on usability.
The details cover a broad range of topics relevent to almost any computing professional. Web programmers will enjoy the _extensive_ discussion of the proper use of form elements. Web designers will welcome the section on the proper use of text vs graphics. Traditional applications programmers will like the section on performance and responsiveness.
Given the very specific nature of the advice, GUI Bloopers doesn't help much with overall, high-level user interface design. For advice of that nature, check out Jef Raskin's "The Humane Interface." What Bloopers DOES provide are some additional details to think about when implementing your UI. It also has good advice on development methodology, including the importance of early and frequent user testing.
And this book definetly needed to be written; I identified _MANY_ of the bloopers in my current (fortunately unfinished) application. It also finally convinced me to include user testing in my development process, after several other UI books failed to persuade me of its importance.
My only problems with the book are really more the editor's fault than the author's. Firstly, GUI Bloopers can be overly wordy. For example, Johnson spends 6 pages struggling to get across the idea that extremely small font sizes are bad. Some good editing could probably have reduced the page count by 15%-25%. Also, none of the illustrations have captions explaining what they represent (only numbers), forcing readers to scan the text for references to "figure #21". A decent editor would have pointed this out.
However, harvesting the advice in GUI Bloopers is worth a little rubbernecking. Unless you happen to be a usability guru or quasi-genius, reading GUI Bloopers will definetly improve the usability of your applications.
Were these reviews helpful?   Let us know
Search Customer Reviews
Only search this product's reviews

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
First post:
Prompts for sign-in

Search Customer Discussions
Search all Amazon discussions

Look for similar items by category