countdown boutiques-francophones Learn more vpcflyout home All-New Kindle sports tools Registry

Customer Reviews

4.5 out of 5 stars
4.5 out of 5 stars
Your rating(Clear)Rate this item

There was a problem filtering reviews right now. Please try again later.

Showing 1-8 of 8 reviews(4 star). Show all reviews
on July 7, 2004
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.
0Comment|Was this review helpful to you?YesNoReport abuse
on December 5, 2001
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.
0Comment|Was this review helpful to you?YesNoReport abuse
on July 21, 2001
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.
0Comment|Was this review helpful to you?YesNoReport abuse
on March 16, 2001
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.
0Comment|Was this review helpful to you?YesNoReport abuse
on December 5, 2000
GUI Bloopers is a catalog of interface design bloopers and fixes. The book is divided into 10 chapters: First Principles, 7 chapters on various categories of bloopers (GUI Component, Layout and Appearance, Textual, Interaction, Web, Responsiveness and Management), Software Reviews (reviews of Eudora Pro 4.0 and Kodak Picture Disk 1.2) and War Stories (accounts of the author's experiences as a consultant to two different software projects).

The book's major strength is that it provides good, detailed descriptions of typical problems and realistic fixes for them. It is not a book of theory or magic bullets but a book for people who want to actually improve their interfaces in a straightforward and substantial way. The book also provides a set of 8 first principles which are the fundamentals of creating good interfaces. There are a good variety of Windows and Mac examples.

The book has few weaknesses and it accomplishes what it set out to do. The most glaring flaw is the lack of captions beside each illustration of a blooper or an example of good design.

I would recommend this book to any interface designer or programmer who writes small in-house applications and does the interface design as well as the coding. There are probably better references if you are looking for something specifically on web design, although the first principles the author discusses certainly hold.
0Comment|Was this review helpful to you?YesNoReport abuse
on May 22, 2000
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.
0Comment|Was this review helpful to you?YesNoReport abuse
on April 30, 2000
I wish I had this book 6 months ago before my company blew money on cruddy software. The front end was absolutely horrible, but being an amateur I couldn't place my finger on what it was. My company bought the software and I bought this book. Just simply looking through the book, I now realize just what the problem with the front end was. Every single "don't" the book tells you to avoid, the software does! It blew my mind just how bad the software was. Too bad Jeff Johnson didn't do the work on the software :^( Why four stars? Some of the concepts, in my opinion, were a little difficult to work with. He gives wonderful "don'ts" for examples, but some of those "don'ts" don't seem to always have a solution for a work around. (Especially when dealing with large amounts of information.) Despite the four stars, any person who writes any code should at least look through this book, or steal a friend's.
0Comment|Was this review helpful to you?YesNoReport abuse
on April 25, 2000
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.
0Comment|Was this review helpful to you?YesNoReport abuse

Need customer service? Click here