Browse Books

Reviewer: Stacy All

Constantine and Lockwood are proponents of a technique to develop better software applications: “usage-centered design.” As defined here, “usage-centered design focuses on the work the users are trying to accomplish and on what the software will need to supply via the user interface to help them accomplish it” (p. 23). This is a change from an often-used human-computer interaction term, “user-centered design.” User-centered design marked a shift in focus from technology-based software development to a process focused on the people who use the systems. The authors suggest that software should be a tool to aid people at work. To build good tools, the nature of the work the tools are used for must be studied and understood. This book is meant for software developers who want to build better systems to meet users' needs, but who need a process framework and design guidelines from which to work. The book is a well-organized, comprehensive guide to developing a user interface from scratch. The first section, “Toward More Usable Software,” offers theories, rules, and principles for usage-centered design. Because software development is a process-based discipline, the authors have developed a model-driven design process for user interfaces, with structured development activities. Section 2, “Essential Models For Usability,” gives in-depth instructions for constructing and developing the three primary models. These models are a method of requirements gathering that involves working with end users. In this section, of particular importance is chapter 4, which defines who real end users are and teaches software user interface designers how to balance and interpret other voices involved in the process. Section 3, “Creating Visual Design,” offers three chapters of concrete suggestions and examples for visual design. The heuristics for font selection, color selection, menu organization, and icon development, and the ways of approaching the construction of the user interface, are clear and extremely helpful. The book is extremely valuable for this section alone. It can help people with limited experience in design to develop their visual thinking skills and make better choices when constructing a user interface. Section 4, “Completing the Design,” synthesizes the abstractions developed in modeling the users' work, and the concrete visual pointers offered in the previous section, into a method for creating a successful user interface. While all of the chapters in section 4 are important, three in particular—chapters 11, 14, and 15—are must-read chapters for software developers. Chapter 11 is a highly informative chapter on designing user help into a system and providing clear and useful error messages. Chapter 14 outlines the paths for and pitfalls of designing Web applications and embedded systems applications. Chapter 15 is a case study, which allows readers to encounter a sample problem set, practice the techniques, and compare their results with the authors'. Section 5, “Assessment And Improvement,” focuses on inspecting, testing, and reviewing as part of the user interface design process. Chapter 16 outlines inspection methods and techniques and compares expert, peer, and user review, while chapter 17 covers metrics and other criteria for judging a user interface design. Chapter 18 describes lab, field, and other methods of user testing. The last section of the book, “Organizing and Managing the Process,” addresses implementing the user interfaces, making the most of users' skills in the development process, and organizing a team to improve software usability. The substantial list of references, index, and glossary give the reader easy access to important resources and useful information. This book is designed for software developers who are searching for a process for producing software that more closely fits the need of the user, and who are looking for a useful resource for understanding visual design. It is also an excellent text to incorporate into software engineering training, because it offers real solutions to common problems with creating user interfaces. I appreciated reading a book by software engineers that emphasizes beginning a software development process by looking at how the software will be used. This book offers a solid process for implementing usage-centered design, from selecting the appropriate users to study, to the in-depth but useful modeling process, and from the helpful visual design principles and usability rules to translating the pieces into a real interface design. The model-driven design process will take some time to learn and implement, but the benefits will be evident in the final product.