Software for Use: A Practical Guide to the Models and Methods of Usage-Centered Design
Larry L. Constantine and Lucy A.D. Lockwood, 1999
New York, NY: ACM Press
ISBN: 0-201-92478-1
List Price: $44.95
"Larry Constantine and Lucy Lockwood... have built a quiet yet ardent following for placing forward... a methodology for effective user interface design. This method is laid out in their meaty volume, Software for Use: A Practical Guide to the Models and Methods of Usage-Centered Design."Reviewed by Eric Patterson
|
@ the reviewer |
|
Eric Patterson is a Principal Information Architect at XOR in Boulder, Colo.
|
Like any other discussion these days about Web interface design, this review will start with Jakob Nielsen. Proclaimed as a usability guru for his early insistence on working usability considerations into Web site development, Nielsen more recently has become a shrill if not arrogant usability pundit, dispensing directives in an almost sound-bite fashion and daring Web designers to ignore them at their own peril. This is seen to strong effect in his recent Alertbox columns (http://www.useit.com/alertbox/) and in his most recent book, Designing Web Usability: The Practice of Simplicity.
Meanwhile, Larry Constantine and Lucy Lockwood, while not commanding Nielsen's reputation - or astronomic consulting and appearance fees - have built a quiet yet ardent following for placing forward what Nielsen does not: a methodology for effective user interface design. This method is laid out in their meaty volume, Software for Use: A Practical Guide to the Models and Methods of Usage-Centered Design.
Constantine and Lockwood strike a fundamental distinction between user-centered design and usage-centered design. While user-centered design represents a needed (if slow) shift from a focus on technology to a focus on users, usage-centered design "focuses on the work that 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) In short, the authors write, usage-centered design "provides a scheme for quickly understanding users in relation to systems, their working intentions in carrying out tasks, and the support they need from the system to perform those tasks." (p. xiii)
While Software for Use is targeted at the design of traditional software interfaces, its lessons can be readily applied to the design of Web interfaces. The methodology of usage-centered design focuses on using three simple models, which are detailed within the book's first section. These models are:
- Role model: the relationships between users and the system
- Task model: the structure of tasks that users will need to accomplish
- Content model: the tools and materials to be supplied by the user interface, organized into useful collections and the interconnections among these collections. (p. 30)
The first step in the usage-centered design process is to define the role model; that is, to understand the system's different user roles. (Ch. 4) As defined by the authors, a user role is "an abstract collection of needs, interests, expectations, behaviors, and responsibilities characterizing a relationship between a class or kind of users and a system." (p. 79) For example, for a business automation tool, a user role might be "WarehouseManager." (While very similar to the notion of "actor" advanced by Ivar Jacobson for use-case modeling, user roles differ in that they can be applied to people only, and not to non-human systems.) Another important consideration is the context under which the user role might be operating the system; for example, the WarehouseManager might be interacting with the system highly frequently.
After defining the user roles, the next step is to understand the tasks they need to perform on the system. (Ch. 5) Using techniques such as task analysis, the designer identifies for particular user roles the tasks they will need to perform. These task descriptions are encapsulated in what Constantine and Lockwood call "essential use cases." Essential use cases are structured narratives that pair user intentions in carrying out tasks with system responses to those intentions. Essential use cases differ from traditional use cases in that they are abstract, technology-free and implementation-independent, leaving designers much greater flexibility in designing the actual interface. (As an aside, could the purpose of essential use cases be served by traditional use cases written in a implementation-independent manner, as advocated by Alistair Cockburn in Writing Effective Use Cases? This could allow closer collaboration between interface designers and programmers in defining use cases, and reduce the amount of work performed overall.)
After defining the user roles and the tasks they need to perform, the designer creates a content model; that is, how user intentions and appropriate system responses will be expressed within the interface itself. (Ch. 6) To maintain the flexibility of the interface design process, the authors recommend creating a low-fidelity prototype at first, using Post-It notes, for example, to represent various content elements. This allows these elements to be modified and shifted easily throughout the process of creating an interface that satisfies all essential use cases. Once the low-fidelity prototype has been set, the details are filled in to create a higher-fidelity prototype. As a final step, the designer creates a navigation map that demonstrates the relationships between the interface screens.
Throughout the usage-centered design process, the designer follows a set of rules and principles, which the authors lay out within Ch. 3.
This review has focused on the authors' user interface methodology. But the book hardly stops there. Later chapters address such topics as interface layout, designing icons and menus, implementing prototypes, fitting an interface to the operational context, designing help and help messages, supporting evolving usage patterns, measuring usability, and involving users in the development process.
My only complaint about Software for Use is that it is a somewhat difficult read. Containing some obtuse sentences and some elaborately exposited sections, this book could have benefited from some judicious editing that would have reduced its length and density considerably (and maybe, allowed it to garner attention rivaling Nielsen's Designing Web Usability). It's a hard complaint to make, though, considering the vast amount of ideas and information that Constantine and Lockwood place into this volume.
For all those (like me) who welcome the marked trail of a strong methodology as they scale the steep summit of user interface design, I recommend Software for Use highly. It integrates such diverse concepts as user roles, use cases, content models, prototypes, and operational contexts into a well-organized (if very dense) package. I will refer to this volume for many years to come.
© Internet Technical Group
Last update: December 31, 2000
URL: http://www.sandia.gov/itg/newsletter/dec00/eric_review.html