Customer Reviews

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

5 star:		(21)
4 star:		(9)
3 star:		(1)
2 star:		(2)
1 star:		(1)

 

 

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.

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.

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!

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.

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.

You might be put off by the title - "'Bloopers'? I don't want to know what NOT to design, I want to know WHAT to design." That was my initial reaction. I was looking for a good intro to GUI for a graduate-level course and didn't want to teach by negative example. Well, fret not. Although he uses negative examples, Johnson does it extremely well and buttresses each yang with the yin of positivity - what the design should have done, and why it went wrong. The result is easily the best of the current crop of 'how to design GUIs' texts. It is readable, well-organized, and covers all the basics. I do not agree with the other Amazon reviews which question the negative slant and Johnson's frequent self-references. For me they fit right in and are appropriate. Finally, a usability book which was usability tested, the results used in editing the book, and the whole process reported in an appendix. Marvelous.

If everybody who creates Web sites took Jeff Johnson's advice in this book, the Web would, for sure, be a better place. My only problem with it is that the advice could be better.

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.

Computers and similar devices are the constant butt of jokes for one reason: bad interface design. The problem is that most professional programmers are amateur interface designers, and it shows. And it hurts.

This book is by a pro whose career has been spent in designing interfaces and correcting the errors others make. He knows what he's doing, and we'd all be a lot better off taking his advice.

If you are designing information-based products that interact with people, you should first understand every point GUI Bloopers makes. This is a how-to, with lots of good examples, clearly explained. It is neither a work of psychology nor does it delve deeply into reasons why things work or don't. Read GUI Bloopers along with Norman's delightful book, The Design of Everyday Things (for motivation) and Raskin's thoughtful and thought-provoking The Humane Interface (for future directions).

This book made it instantly into the short list of my top recommended books for people who design interfaces. Get it, read it, follow it. Your customers will thank you.

I think it is pretty clear from the other reviews that the content of this book is very nice. The author is definitely very experienced and his points all make sense. But I _won't_ recommend you buy it (not for now). Go find the book and see it in person first.

I am very disappointed by the poor design of the book. In particular, I completely agree with another reviewer that this book _itself_ is a GUI Blooper: there is practically no caption to all illustrations except "Figure X.Y" with a thumb-up or thumb-down icon to indicate whether the example UI is good or bad. True, the illustrations are all referenced in the rather _dense_ text; but if you look at the illustrations, it is not very instructive as they require you to read the text carefully to know why something is good or bad. (Did I say the text dense?) The author should have added a couple sentences to the captions to summerize his idea.

As for UI design books for programmers, I recommend reading User Interface Design for Programmers by Joel Spolsky first. Then read this one when you have extra time.

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.