Rating: 
Summary: Very useful checklist for your apps
Review: Johnson did a good job in compiling this checklist for all developers out there. I think most of his points are valid and it is not something that requires a PHD to figure out. However, compiling a list alone requires a lot of effort and it well worth your $40 bucks to have a professional done it for you.Like most other readers, I was disappointed in the rather dry writing style (which the cover of the book suggests otherwise). It's bad not because it's dry, it's because this topic really *can* be written in more enjoyable style (and less lengthy). The other bad thing is that this book can be used more efficiently if the illustration and its explanation were combined (with arrows and textbox to point out what's wrong).
I found that while I spent the past two days skimming through the text, in the process I marked each picture in the book so that later on I can use them as a list to check my own apps. I understand that the author might need to put in days/weeks/months to fix this "bug" but it'll save all of its readers' time and make this book worth more than $30 (that's what I value it, with the "bug" fixed, $40) BTW, I found that it's not the UI mistake that's hard to correct. Rather, the problem in GUI development is social one.
If you tell your fellow programmers that something should be done this way and explain all the rational behind it (even he understands it afterwards), he'll still be rather reluctant to correct it because that implies he did it wrong in the first place (or he is not knowledgeable in UI design). The point that the author raises is very valid, that programmers, in the average, are lousy designers and amateurs in preparing presentation and layout. In summary this is definitely an educational book in UI design. But someone might as well publish all these ideas in a website with less words and more illustrations and accomplish the same goal more efficiently. And I would pay for it as it saves my time and I can educate the whole team (it's hard to ask your fellow programmer to read a 600 pages book with a topic that he would care less otherwise) and ultimately makes our product better.
Rating:
Summary: Good pratical advice
Review: Overall I liked this book. It has many practical guidelines, that you can apply immediately. My only problem was there were many trivial bloopers and many bloopers which may not be bloopers. Again and again he refers to his reviews of client software. He rarely refers to his user studies or other research. This makes me question if some of his bloopers are really bloopers or just his opinion.
Rating:
Summary: Good pratical advice
Review: Overall I liked this book. It has many practical guidelines, that you can apply immediately. My only problem was there were many trivial bloopers and many bloopers which may not be bloopers. Again and again he refers to his reviews of client software. He rarely refers to his user studies or other research. This makes me question if some of his bloopers are really bloopers or just his opinion.
Rating:
Summary: Useful but Not Fun to Read (Graphic Design Perspective)
Review: 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.
Rating: 
Summary: An essential for GUI designers
Review: Provides clear direction for the design of usable GUI's in an approachable manner. A great beginner's guide and a valuable reference for the seasoned GUI designer or HCI specialist.
Rating:
Summary: Practical Information for Real-Life Practitioners
Review: Since reading this, I've run across several UI bloopers on a project and was able to speak with authority about them. As the book predicts, the programmer resisted fixing them. But the book helped me make a strong case. The results? Better products, less support needed, happier customers. Valuable Book.
Rating:
Summary: Practical Information for Real-Life Practitioners
Review: Since reading this, I've run across several UI bloopers on a project and was able to speak with authority about them. As the book predicts, the programmer resisted fixing them. But the book helped me make a strong case. The results? Better products, less support needed, happier customers. Valuable Book.
Rating:
Summary: One of the Classics of GUI Design
Review: The farther I read into GUI Bloopers, the better it gets! Everyone, whether designer or developer, novice or expert, should keep a copy nearby. An invaluable resource. Designers will find it a great resource for ensuring their designs cover all the bases, while developers will see that design involves much more than writing code. Users should insist that any development group involved with GUIs should have a copy for each developer -- and that it's read!
Rating:
Summary: Wish I had this book 10 websites ago...
Review: Then while designing my websites, I would have saved countless hours trying to figure out what is good usable GUI design versus GUI 'bloopers'. This book is chock full of pratical information which you can put to use immediately. It is organized so that you can easily look up interface design do's and don'ts by category. The author discusses each blooper in great detail and cites what should be avoided and then recommends corrective actions. To further enhance the readability, most of the do's and don'ts are illustrated with screen images. Whip this book out in customer design meetings, when discussions get bogged down about label placement, font size, alignment, menu items, responsiveness, error messages, page length, links, checkboxes, radio buttons, toggles, navigation etc, etc, etc. This book will definitely elevate the usability of your websites to new heights!
Rating:
Summary: Good Overall
Review: This book explains more "don't" than "do." I found several instances within projects I've been involved that Mr. Johnson rails against, and after reading his explanation, I tend to agree. That isn't to say that one will agree with everything Johnson says(you won't), but for the most part he was very insightful. My only complaint is that there aren't enough examples of how to avoid some of the problems(in some cases the remedies are only applicable in simplistic situations) - the section on TTY interfaces especially. Also note, that while the book often touches on web interfaces, the text is obviously geared towards traditional software developers. Overall, a worthy purchase.
| 
