Usability Testing

In addition to finding the previously mentioned user interface implementation problems, you can also test for usability problems. What is the difference? What I'm calling an "implementation problem" is a problem related solely to the implementation of the user interface and not to its design. Theoretically, you could find all of these problems by inspecting the source code and resource files directly. On the other hand, usability problems relate to the user's ability to actually use the program. To find these problems, you have to test the program using real tasks.

You could find many usability problems by reviewing your program with a checklist of possibly hundreds of low-level attributes that good user interfaces have. In fact, the Sample User Interface Guidelines presented in Chapter 4, "Establish a Consistent User Interface Style," could be used as a basis for such a list. I like to review such lists when testing a program because I always seem to find a couple details that I overlooked.

Instead of trying to review hundreds of low-level attributes, an alternate approach is to check for usability problems by using a list of high-level design principles that are known to be effective in finding such problems. The technical term for this type of testing is heuristic evaluation. A heuristic is an approach to problem solving that uses self-education to obtain the desired results. In other words, we can develop our own knowledge of effective user interface design to find usability problems instead of (actually, in addition to) direct user testing. Of course, you can use this technique at any time during the software development process, especially during the design phase. Clearly, waiting until the program is just about to ship is too late.

There is a standard process for heuristic evaluation recommended by usability experts, and that process has two significant attributes. The first is that you should perform the design review using a group of usability experts—the more usability experts the better. (What a surprise!) The second is that the usability evaluators should work independently, since independent points of view are more likely to uncover different problems. After all, there is no advantage to having more than one person find the same problem. Just in case you don't have a crew of usability experts at your disposal, you might want to try to use the same evaluation process with your team members. Use this technique to get early feedback on the user interface design from everyone involved in the project, including users, testers, graphic designers, technical writers, and managers. As you shall soon see, these design principles used during heuristic evaluation are not difficult to understand and apply, as long as you make the appropriate change in perspective.

TIP

---

Evaluate the usability of your program with your team members by using a short list of high-level design principles.

A Usability Roadmap

Jakob Nielsen recommends using the first 10 of the following design principles in Chapter 5, "Usability Heuristics," of Usability Engineering. The remaining four principles are from Designing for the User Experience. I'll give a brief description of each principle as well as references to the chapters in my book that relate to that principle. You should be able to use this list as a usability roadmap.

Simple and natural dialog

Good user interfaces are simple; have natural mappings; and use good arrangement, flow, and grouping. In this case, "dialog" refers to all interactions between the user and the interface, not just dialog boxes.

Chapter 15, "Keep It Simple," gives suggestions on how to achieve simplicity, particularly how to simplify a window's layout and appearance. Chapter 13, "Learn from the Web," describes how to take advantage of Web-based technology to make programs that are simpler and easier to use and features that are easier to find. Chapter 12, "Learn from The Design of Everyday Things," discusses how to create natural mappings to make a clear relationship between what the user wants to do and the mechanism for doing it. Chapter 4, "Establish a Consistent User Interface Style," and Chapter 29, "Check Your Dialog Boxes," give guidelines on how to organize windows to obtain good arrangement, flow, grouping, and such.

Speak the user's language

Good user interfaces use words, phrases, concepts, and graphics that the user understands. Appropriate metaphors can be used to express unfamiliar concepts in the user's language.

Chapter 3, "Establish Consistent Terminology," discusses the importance of establishing consistent terminology in eliminating confusion. Chapter 30, "Check Your Error Messages," describes how to phrase error messages in a way the user can understand. Chapter 12, "Learn from The Design of Everyday Things," discusses natural mappings, particularly in how they eliminate the need for translation. It also discusses some of the problems with using metaphors. Chapter 19, "Configurability Is Cool," Chapter 34, "Use System Colors," and Chapter 35, "Handle All Video Modes," help you speak the user's language by having your program adapt to the user rather than the other way around.

Minimize the user's memory load

The user should not have to memorize anything to use your program. The information required to use the program should be contained within the program itself.

Chapter 10, "Good User Interfaces Are Visible," describes how to make your user interfaces visible, so that users can figure them out just by looking at them. Chapter 12, "Learn from The Design of Everyday Things," describes how to use constraints so that the knowledge required to use an object is contained within an object itself. It also discusses affordance, which allows the user to determine how to use an object just by looking at its visual clues. Chapter 13, "Learn from the Web," describes how Web pages compensate for not having help by putting detailed instructions in the user interface itself. Chapter 17, "Direct Manipulation Is Cool," discusses the advantages of direct manipulation, which is one of the easiest forms of interaction to use.

Consistency

Good user interfaces use consistent terminology, have windows with a consistent appearance, and have commands with consistent behavior. Such programs are consistent within themselves and with other programs.

Chapter 1, "Know the Standards," discusses the importance of knowing and following the standards, which will make your program consistent with others. Chapter 3, "Establish Consistent Terminology," discusses the importance of establishing consistent terminology in eliminating confusion. Chapter 4, "Establish a Consistent User Interface Style," gives sample user interface guidelines to help you achieve consistency. Chapter 16, "Prefer the Standard Controls," describes the advantages to using standard controls, the most important being that users already know how to use them.

Feedback

Good user interfaces use feedback to indicate to the user that a task is being done and that it is being done either correctly or incorrectly. Your program needs to inform the user what it is doing. Without feedback, the user is giving commands without any knowledge of their results. Feedback completes the loop. Since the user needs to know when an action cannot be done or is being done incorrectly, error messages are also an important form of feedback.

Chapter 10, "Good User Interfaces Are Visible," describes when to give feedback and how to make it visible. Chapter 12, "Learn from The Design of Everyday Things," describes the attributes of good feedback and compares the different forms of feedback. Chapter 20, "Previews Are Cool," and Chapter 21, "Tooltips Are Cool," describe two excellent forms of feedback. Since good feedback is immediate, Chapter 25, "Speed Is a User Interface Issue," gives some tips on how to improve both the actual and perceived speed of a program. Chapter 30, "Check Your Error Messages," describes how to phrase error messages in a way that provides useful feedback.

Clearly marked exits

Good user interfaces allow the user to recover from mistakes quickly, either by exiting an undesired window quickly or by returning to a known location. Such actions should not require the user to jump through any unnecessary hoops.

Chapter 12, "Learn from The Design of Everyday Things," describes visible navigation, which has an attribute of having a clearly marked exit. Chapter 13, "Learn from the Web," discusses the value of home pages and the advantages of the Web Browser Navigation Model. Chapter 22, "Unnecessary Dialog Boxes Are Evil," discusses the problems with unnecessary confirmations, such as confirming a program exit.

Shortcuts

Good user interfaces accommodate advanced users by letting them get their work done efficiently. Advanced users appreciate features like toolbars, context menus, keyboard shortcuts and access keys, and direct manipulation.

Chapter 4, "Establish a Consistent User Interface Style," gives guidelines on when to provide shortcuts and access keys. Chapter 6, "Beginning vs. Advanced Users," and Chapter 7, "Using Applications vs. Utilities," describes the features that are appropriate for advanced users and applications. Chapter 18, "Appropriate Defaults Are Cool," and Chapter 24, "Unnecessary Repetitive Tasks Are Evil," discuss ways to eliminate unnecessary repetition by providing appropriate defaults and by keeping track of the user's input. Chapter 17, "Direct Manipulation Is Cool," gives many examples of direct manipulation, which is a good shortcut for advanced users.

Good error messages

Good error message text must provide enough information so that the user can understand the problem and know what to do about it. Typically, an error message needs to provide a notification that indicates a problem occurred, an explanation that explains why the problem occurred, and a solution that suggests how to solve the problem. Furthermore, good error message text is brief, clear, consistent, and specific.

Chapter 30, "Check Your Error Messages," describes how to phrase error messages that give a notification, explanation, and solution in a way that is brief, clear, consistent, and specific.

Prevent errors

The best error message is often no error message at all.

Chapter 23, "Unnecessary Message Boxes Are Pure Evil," gives suggestions on how to eliminate unnecessary error messages. Chapter 12, "Learn from The Design of Everyday Things," describes how to use constraints to eliminate error messages by making it impossible for the user to make a mistake. Chapter 17, "Direct Manipulation Is Cool," discusses how direct manipulation eliminates the need for error messages when the manipulation is properly restrained.

Help and documentation

Good user interfaces shouldn't require the user to read any external documentation, but good programs should provide short, task-oriented help when the user needs it. While users don't read Help unless they have to, when they do read it they want it to answer their questions. If Help doesn't answer their questions, they are not happy.

Chapter 32, "Check Your Help System and Documentation," describes the attributes of good Help, how to prepare your program for Help, tips on how to work with technical writers, and how to find problems in the documentation.

User in control

Good user interfaces keep the user in control of the software, rather than the other way around. This means that the user should determine what the program does, in terms of both interaction and appearance.

Chapter 22, "Unnecessary Dialog Boxes Are Evil," shows how unnecessary modal dialog boxes force the user to react to the program and how such dialog boxes can be eliminated. Chapter 19, "Configurability Is Cool," Chapter 34, "Use System Colors," and Chapter 35, "Handle All Video Modes," help make sure that the user has control over the program's appearance.

Direct manipulation

Direct manipulation is a natural way to perform tasks in a modern graphical user interface that is easy to learn, and quick and convenient to use. You feel like you are directly in control of a task and the continuous visual feedback makes it easy for you to decide when you have what you want. Direct manipulation makes using software fun. It is the ultimate form of interactivity.

Chapter 17, "Direct Manipulation Is Cool," discusses the advantages of direct manipulation and gives several examples.

Forgiveness

Good user interfaces allow the user to explore the program by using trial and error. Your user interface needs to warn users when they are about to perform a function that is potentially destructive or difficult to undo. You should consider putting the burden of correcting mistakes on your program instead of the user by providing an Undo command.

Chapter 11, "Good User Interfaces Are Invisible," discusses the importance of forgiveness. Chapter 23, "Unnecessary Message Boxes Are Pure Evil," gives guidelines on what actions need to be confirmed and what actions don't.

Aesthetics

Lastly, the visual appearance of a user interface plays an important role in the program's ability to communicate to the user and the user's overall satisfaction with the program. Good user interfaces keep the user informed without being distracting.

Chapter 4, "Establish a Consistent User Interface Style," presents sample user interface guidelines that help you get "le look." Chapter 11, "Good User Interfaces Are Invisible," gives suggestions on how to make sure your program doesn't draw unwanted attention. Chapter 22, "Unnecessary Dialog Boxes Are Evil," describes how to prevent unnecessary dialog boxes, which can be very distracting. Chapter 28, "Talk to Your Other Team Members," gives tips on how to take advantage of the talents of a good graphic designer.