Tech Quarto
Search Advanced SearchView Cart   Checkout   
 Location:  Home » Computer Science » Web Graphics » GUI Bloopers: Don'ts and Do's for Software Developers and Web Designers (Interactive Technologies)  
Categories
Computer Science
The Internet
For Dummies
Web Browsers
Windows
Digital Culture
Multimedia
Mobile & Wireless
Subcategories
All Titles
Arts & Photography
Biographies & Memoirs
Business & Investing
Children's Books
Computers & Internet
Cooking, Food & Wine
Engineering
Entertainment
Gay & Lesbian
General AAS
Home & Garden
Literature & Fiction
Medicine
Nonfiction
Outdoors & Nature
Parenting & Families
Professional
Reference
Religion & Spirituality
Science
Teens
Travel
Mass Market
Trade
Related Categories
• Web Graphics
Web Design
Web Development
Computers & Internet
Subjects
• Website Architecture & Usability
Web Development
Computers & Internet
Subjects
Books
• General
Programming
Web Development
Computers & Internet
Subjects
• General
Graphics & Multimedia
Programming
Computers & Internet
Subjects
• Software Development
Software Design, Testing & Engineering
Programming
Computers & Internet
Subjects
• General
Programming
Computers & Internet
Subjects
Books
• General
Graphic Design
Computers & Internet
Subjects
Books
• General
Computers & Internet
Subjects
Books
• Human-Computer Interaction
Computer Science
Computers & Internet
Subjects
Books
• General
Software
Computers & Internet
Subjects
Books
• General
Environmental
Civil
Engineering
Professional & Technical
• Graphics & Visualization
Computer Science
New & Used Textbooks
Custom Stores
Specialty Stores
• Software Design & Engineering
Computer Science
New & Used Textbooks
Custom Stores
Specialty Stores
• All Amazon Upgrade
Amazon Upgrade
Custom Stores
Specialty Stores
Books
• Computers & Internet
Amazon Upgrade
Custom Stores
Specialty Stores
Books
• Qualifying Textbooks
Custom Stores
Specialty Stores
Books
• Paperback
Binding (binding)
Refinements
Books
• Printed Books
Format (feature_browse-bin)
Refinements
Books
Visit Laptop Nirvana for the best Cheap Discount Laptops

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

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

zoom enlarge 
Author: Jeff Johnson
Publisher: Morgan Kaufmann
Category: Book

List Price: $63.95
Buy Used: $5.16
You Save: $58.79 (92%)



New (10) Used (17) from $5.16

Avg. Customer Rating: 4.5 out of 5 stars 34 reviews
Sales Rank: 166058

Media: Paperback
Edition: 1st
Number Of Items: 1
Pages: 584
Shipping Weight (lbs): 2.3
Dimensions (in): 8.9 x 7.3 x 1.3

ISBN: 1558605827
Dewey Decimal Number: 005.437
EAN: 9781558605824
ASIN: 1558605827

Publication Date: March 17, 2000
Availability: Usually ships in 1-2 business days
Shipping: Expedited shipping available
Condition: The book is clean but may have highlights.

Also Available In:

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

Similar Items:

  • Don't Make Me Think: A Common Sense Approach to Web Usability, 2nd Edition
  • Designing Interfaces: Patterns for Effective Interaction Design
  • The Design of Everyday Things
  • The Inmates Are Running the Asylum: Why High Tech Products Drive Us Crazy and How to Restore the Sanity
  • Designing Web Usability (VOICES)

Editorial Reviews:

Amazon.com
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

Product Description
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.


Customer Reviews:   Read 29 more reviews...

5 out of 5 stars Excellent Reference for Designers & Developers   September 11, 2007
If you are a designer who has to explain to developers what they are doing wrong, get this book (or maybe the next edition, out soon). I loved this book for how well it explained every bad interface design blooper I had ever seen at that point & helped me understand why developers created many of these problems. It helped me explain to developers why there were better solutions & how to design them. It also contains an excellent introduction to user-centered design. It's a very well organized and valuable reference for interface designers & a great gift for any open-minded developer interested in good UI design. I'm looking forward to his next edition.


5 out of 5 stars Great book to get started on UI design   September 7, 2006
 1 out of 1 found this review helpful

This was my first book on user interface design, and it was a great choice. It gives good information on principles and also provides specific usable information for how to use controls, etc. I found the organization of the book easy to use and enjoyed reading it.


4 out of 5 stars Good book, still useful   September 28, 2005
 4 out of 4 found this review helpful

The author of this book does a very good job of describing and illustrating common GUI design mistakes. He has categorized the problems in broad topics such as "GUI Component Bloopers" and "Interaction Bloopers", then gives concrete examples of the bloopers that occur within each broad topic. The individual bloopers are well illustrated, and examples of better approaches are given.

Even though the applications used in the book are from the nineties, they are still very applicable, since the advice given frequently transcends the tools used to build the screens. It is applicable to web applications as well.

I read through this book once, and now use it as a reference.



1 out of 5 stars Too old   July 25, 2005
 3 out of 22 found this review helpful

Don't buy this book, it refers to applications written in early '90. Today it is completely a different story.


5 out of 5 stars Excellent text for my GUI programming class   July 9, 2005
 8 out of 8 found this review helpful

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.


Powered by Associate-O-Matic