Microsoft Silverlight Books

Outstanding

GUI Bloopers is lucid and compelling, and fun to read. It's one of the best books on UI design that I have encountered.

Benjamin Glick
31 August, 2009

Excellent book for developers who are not interaction experts

This book is aimed at programmers and software developers who might not have much if any formal training in UI design and interaction design.

Each chapter is named after a class of common errors (e.g. 'Navigation Bloopers', 'Taking control away from users', etc.) and gives many examples of the error, and shows how to fix the errors.

The book seems to focus about equally on desktop application UI and web UI, so both types of developers will find it handy.

Note that there's probably not much new here if you're already an experienced UI/interaction designer or usability expert.

A. Benenson
07 April, 2009

Well written compilation of common GUI errors

This is a very well written and very readable book, but readers should not expect to learn as much as from a typical good book of 407 pages because most of bloopers described in the book can be avoided just by common sense. I suspect any experienced software developer with some experience of interaction with customers would be able avoid the vast majority of the bloopers especially those illogical ones. However this book still has great value because it enhances common sense and systematically organizes bloopers into categories: GUI control, navigation, textual, layout, interaction and responsiveness. It also talks about how to manage bloopers.

GUI is a very difficult topic to write about because it involves both art and science. The science part is psychology or cognitive science. GUI evolves constantly. One can list all the principles in a few sentences (e.g. logical, intuitive, simple, visually appealing, etc.), but one can compile much more bloopers than this book contains. I think this book has about the right balance. All application developers can benefit from reading this book or some literature like this. However such book does not have much reference value for sitting on a bookshelf, so get the book, read it and pass it to a friend.

H. Zhang
30 March, 2009

Always good to Keep good principles in mind.

I've been developing software for about 12 years and I think is good to have GUI principles reviewed every couple of years. This book is easy to read, has good practical examples, it may seem sometimes simple and basic but still, I'm sure we all make UI bloopers so it's good to keep them in mind. It helped me a lot with some vices created through years and/or certain projects. I'm thinking on passing the book to one of the PM's. I'm sure he will find a couple of good tips. Even if you think you are a good software guy, this may be helpful, either validate or give you some guidance.

Fernando J. Guzman
16 December, 2008

Revalues the importance and complexity of GUI design

The introduction of programming tools such as VisualBasic probably contributed to the misperception that designing a form was something easy to achieve. Using drag and drop controls to build a form certainly is, but creating an unambiguous and task-oriented screen flow is another story.

Jeff Johnson did an excellent job. The chapters arrange the "bloopers" into meaningful categories (GUI Controls, Navigation, Textual, etc) and the table of contents makes it very easy to locate a specific topic.
Personally, I like his approach of "Don'ts followed by Dos". Presenting an example of bad design first, forced me to try to spot where the mistakes were (not always an easy task) and this contributed, in my opinion, to a better learning experience. Another nice surprise was to learn in appendix B, the way this second edition was "usability-tested" and also, a very important although not so obvious concept, "Reviewing is not usability-testing".

This book is very easy to read and understand and I would certainly recommend it to every developer (from beginner through to senior level) involved directly or indirectly with any GUI design or implementation.


Edelmiro Fuentes
07 November, 2008

Best GUI book, evah.

Having studied Human Computer Interaction and Psychology in school and developing websites for almost 10 years I still feel like I learn something new every time I peruse this book. It's solidly based on psychological mechanisms like attention span, association, mental modeling, and some obvious real-world experience. I can honestly say that anyone who designs GUI's (web-based, app-based, well anything really that has a user interacting with a screen) should buy this book. In fact even physical interfaces could benefit from reading this book. Even the most disciplined designer needs to be reminded of the "U" in GUI...it really is all about the user.

S. Quinn
16 September, 2008

A worthwhile and useful read

This book is aimed at both desktop application GUI developers and website developers. It shows real world examples of bad practice and for each one shows how to do things better. The book strongly advocates a user and task focused view of software. The book is interesting, and at times thought provoking. One area that the book only touches on in passing is accessibility---that's a big topic in its own right but more mention could have been made of it. This is not a book about "fonts and colors", but about user interaction: how to make it as easy and natural as possible for users to complete the tasks they want with the software.

I would recommend this book to anyone doing application or website design since at the very least it will make you more conscious of your users, as well as providing many helpful ideas about how to do things in ways that work.

M. N. Summerfield
11 February, 2008

Very Informational

I'm only about half way through the book, but so far i'm pretty happy with this book. I'm a UI designer, and I began to get worried that this book was aimed more at developers and programers, thus not being much use for me. As I read on i realised that it is very well rounded for all involved in the process from begining to end, and provides a very good base of information on the priciples of designing for the user. the introduction actually recommends different chapters for differnet people (UI designer, developer, etc), making it a great tool without having to read the entire book if you don't want to. It also seems to up to date as of the end of 2007.

Jonathan Broom
27 January, 2008

so you thought you knew about User Iterface design?

I thought I understood ease of use on the web, until I read this book! Jeff Johnson REALLY understands UI design--there are pages and pages of pearls in this book, useful tidbits that continually had me saying "why didn't I think of that?!", and demonstrating the value of his significant experience in this area.

Also, as a manager, I learned a lot about the different collaborative roles that must come together (graphics vs. developer vs UI, etc.), and how managers can sabotage their important web project by ignoring or postponing UI design until it's too late. For managers, this section of the book alone is worth the price.

Highly recommended.

T. Del Favero
28 November, 2007

Uncompromising and unforgiving

This guy does not care very much about hard it is to accomplish any particular GUI design. A GUI blooper in his mind is a GUI blooper and you better do something about it if you value customer reception of your product. He often suggests solutions to difficult problems that might not be obvious to developers and that somewhat alleviate the effort involved in overcoming the blooper.

He pretty much covers the entire range of GUI bloopers that developers are likely to make, and gives a plethora of examples, both from real applications and invented for the sake of illustration. The book is well organized and after reading the book from cover to cover, I now feel I'll be able to go back to the book and find fairly easily his treatment of a particular category of blooper and review his recommendations.

I like the fact that he clearly explains why bloopers are bloopers and the severity that users are likely to rate each one of them. He often points out particular bloopers that may be especially hard to fix and are also especially onerous to users, but he doesn't care. As I said, for the author, a blooper is a blooper and must be dealt with. He always puts needs of the user before the difficulties of the developer and has little patience with claims that it's just too hard or expensive to get rid of a particular blooper. I guess the thing is, if you think it's too hard, you shouldn't be in this business.

Frank Paris
24 November, 2007

Excellent GUI reference

This is a wonderful book! It's well organized and comprehensive, a quick and entertaining read, even for those without the technical credentials to design a web site. There are lots of examples that make the concepts easy to understand and apply.

We're hiring software developers to design our new website. GUI Bloopers 2.0 gave us a common language we can use to engage with prospective teams. Most important, the Management Bloopers chapter points out how managers can undermine the best web design and how to avoid it. It's a great guide for professionals, but I also highly recommend it to everyone who works with them.


J. Roberts
19 November, 2007

GUI Bloopers 2.0 earns my "two thumbs up". It

Once upon a time, graphical user interfaces (GUI) were found only in operating systems for PCs. Today, we are confronted with a GUI when we use self-service checkout counters, when we pay bills online, and when we use our mobile phones, to name a few examples. Whether we can complete our transactions or accomplish our tasks depends on having a GUI that is easy to use and easy to understand. No doubt you have seen people confused with the touch-screen menu at the self-service checkout counter, or abandon their online shopping cart because the form is confusing. You may well have chosen a competitor's brand of income tax preparation software because it is easier to use. Frustrated users mean lost income and products that fail in the market place. When GUI's fail, that's when companies call a user interface designer like Jeff Johnson to change poor design into great design.

The first edition of GUI Bloopers heralded Johnson's first work as a book author. GUI Bloopers was intended for software developers who often work double as user interface designers, development managers, and new user interface designers. But GUI Bloopers also gained popularity among teachers and technical writers who wanted to understand the rules of good user interface design. Readers' feedback, new software products and Web applications on the market inspired Johnson to write an updated version--GUI Bloopers 2.0.

GUI Bloopers 2.0 describes common user-interface mistakes found in today's software products and services, and provides design rules and guidelines to avoid them. Johnson describes the design decisions that lead to misuse of controls, poor navigation, prose-riddled labels, bad design and layout, faulty interaction, and poor responsiveness. GUI Bloopers 2.0 is well illustrated with hundreds of examples from real products and online services, and stories from his own experience. To compare and contrast good and bad design, Johnson gives a "thumbs up" for good design and a "thumbs down" for a blooper.

The book contains the following chapters:

Chapter 1, First Principles, describes nine principles of product design: focus on the users and their tasks, not on the technology; consider function first and presentation later; conform to the users' view of the task; design for the common case; don't complicate the users' task; facilitate learning; deliver information and not just data; design for responsiveness; and try it out on users and then fix it. Too often, the rush to deliver products means ignoring one or more of these principles. Johnson could have omitted this chapter and jumped right into describing GUI bloopers, but it provides an informational foundation for the discussion of bloopers.

Chapter 2, GUI Control Bloopers, is the first of six chapters dedicated to GUI design details. It describes the most common misuses of controls (i.e. checkboxes, tabs, input fields and buttons) and how to avoid them.

Chapter 3, Navigation Bloopers, emphasizes the importance of cues to let people know where they are, where they have been, and where they can go. This chapter describes the most common navigation mistakes and how to design effective navigation cues.

Chapter 4, Textual Bloopers, describes how inconsistent and unclear terminology, poor writing, jargon, and misleading text can confuse users. The typical GUI contains a lot of text, and if it's poorly written, users can easily get lost. Peer reviews of the user interface by developers do not uncover these errors if they cannot recognize them as confusing. For example, an error message that describes a script error is informative to a developer but meaningless to a user, -. Johnson offers suggestions for educating development teams about good writing and acceptable terminology, and how to conduct reviews to identify textual bloopers.

Once the GUI controls have been added, properly labeled and any supplemental text has been written, it is time to decide on presentation: layout, colors, and text fonts. Chapter 5, Graphic Design and Layout Bloopers, presents guidelines on layout and window placement, colors, and text fonts. You will learn valuable presentation guidelines that will make user interface easier to read and understand. Unfortunately, Johnson was unable to provide examples of bloopers showing poor use of color because the book is printed in black and white. However, he covers color bloopers in a Web Appendix at www.gui-bloopers.com.

Chapter 6, Interaction Bloopers, is the first of two chapters that describe the mechanics that underlie the user interface. In this chapter, Johnson presents the user interface design principles that affect human perception, reading, information processing, and problem solving. The chapter clarifies why violating these principles results in a software product that is hard to learn and frustrating to use. Some of the design mistakes covered in this chapter are driven by business rules and processes mandated by clients and corporate policy. If those business rules and processes do not contribute to usability, this chapter will educate you on how to make an argument for improving interaction.

Chapter 7, Responsiveness Bloopers, is the second chapter that deals with the mechanics that underlie the user interface design. In this chapter, Johnson describes the reasons for poor responsiveness and the design principles for improving responsiveness. Before I read this chapter, I assumed that sticky buttons, frozen cursors, and lagging scrollbars (to name a few) meant that my PC was too slow. After reading this chapter, I learned not to confuse responsiveness with performance.

Chapter 8, Management Bloopers, describes management misconceptions and mistakes that lead to poor product usability. Other authors have dedicated whole books to management-level problems that affect usability. Johnson could have easily omitted this chapter and listed those books as references. However, he does not just rant about why poor management leads to poor usability; he provides strategies and suggestions to educate management about usability.

GUI Bloopers 2.0 is supplemented by a Web site, www.gui-bloopers.com, which provides the following information:

* GUI Bloopers checklist: a check list of all of the types of bloopers in the book to facilitate checking software before release.
* Web Appendix: Color Bloopers: two bloopers about poor use of color that could not be included in the book because the book is not printed in color.
* More bloopers: additional bloopers not included in the book, starting with bloopers that did not make the "final cut".

GUI Bloopers 2.0 earns my "two thumbs up". It is well written, well researched, and an essential resource for anyone developing software products and Web applications.


David Dick
11 September, 2007