I recently finished reading User Interface Design for Programmers by Joel Spolsky, and I must say, I like it. Here is why.
Joel is a programmer, which means that he, unlike most UI folks, can relate to the pain of programmatically designing user interfaces. On top of that, he has a rather exceptional way of staying on topic, while making jokes about various semi-related topics.
In the following, I sum up the points made by Joel during the books’ 18 shortish chapters.
Chapters 1 and 2 discuss user and program models, That is, the way the programmer and the user sees the tasks that the program attempts to accomplish. The main points revolve around aligning the program model with the users model, which pretty much always entails keeping the program model very simple. This leads directly to chapter 3, which is appropriately titled “Choices”.
The central point of chapter 3 is to only provide the user with choices, if they are really really needed. That is, don’t ask the user questions or provide options just because someone implemented some feature that they love ever so much. Like in all other chapters, the main point is summed up in a large reading friendly font: “Every time you provide an option, you are asking the user to make a decision”. The implication clearly is that superfluous choices are bad.
Chapters 4 and 5 discuss metaphors. That is, how to use real world concepts to make the the user understand how stuff is supposed to work. The chapters basically provide a programmer friendly introduction to many of the points presented by Norman in “The design of everyday things”. It is quite useful, and makes appropriate fun of a number of well known software building organisations, for either ignoring or overdoing the use of metaphors.
Chapter 6 discusses user interface consistency, and the lack thereof. And the central point here is “Good UI designers use consistency intelligently, and though it may not show off their creativity as well, in the long run it makes users happier”. I wholeheartedly agree. In fact, it is the single most annoying user interface issue when using Unix based graphical desktop programs: They mostly have totally inconsistent behaviour, both across programs and within single programs.
Chapter 7 discusses the important distinction between usability and learnability. The discussion is based on a comparison between generations of user interfaces, starting with the basic CLI, and ending with the kind of stupid 1 page wizards at which particularly Microsoft excel.
Chapters 8, 9, 10, and 11 discuss designing for extremes. This can essentially be summed up by naming the chapter titles “People can’t read”, “People can’t control the mouse” and finally “People can’t remember”. The point that Joel is trying to make, is that designing as if these statements were true will usually result in added usability for the average user of whatever program you’re designing. The chapters are spiced up with a number of excellent examples from real world user interfaces, which really help in getting the message across.
Chapters 12 and 13 focus on designing programs for users. Be they imaginary or usability testing subjects. I didn’t find these chapters all that interesting, as Joel spends a significant portion of these chapters explaining how spontaneous usability tests with whatever non-developer person you can get your hands on are mostly just as usable as elaborate usability tests performed in an appropriately designed map, and how programmers are generally worried about going changing stuff which was included because some usability test indicated that it would be a good idea. You get most of this “for free” if you follow some of the most obvious advice provided as part of
the extreme programming principle.
Chapter 14 talks about time, and how time is important in a number of ways when designing user interfaces. It has a number of obvious points, which are not quite so obvious until you’ve actually read about them.
Chapter 15 discusses “smartness” in software. Ie. it discusses how heuristics may be used to improve the user interface, if the heuristic is chosen and implemented appropriately. As an example heuristic, take auto completion in Microsoft Word. I leave it to you decide whether you think that is appropriately implemented.
Chapter 16 is entitled “Tricks of the trade”. ’nuff said.
Chapter 17 talks about user interface design for the web. Its main point is that usability applies as much to web site design as it does to application design. Unfortunately, the book is old enough (© 2001) to not really deal with technologies like ajax. In stead Joel spends much time talking about reloading web pages at modem speeds, which is not really the relevant for a rather large number of users these days.
Chapter 18 is the obligatory “taking a step back” chapter.
All in all, I found the book entertaining and useful. I am definitely going to try to apply some of the advice provided. I do wish that Joel would have spent a bit more time discussing “power users” and their user interface design requirements. In stead he pretty much writes of command line interfaces as ancient and mostly useless (p. 76).