Notes on design practice: stories and prototypes as catalysts for communication

Reviewer: Hans J. Schneider

Scenario-based design is a topic of increasing importance in user interface design. Scenarios focus on describing particular instances of use and on a prospective user's view of what should happen. Scenario-based design appears to be at the heart of a new design paradigm, but it is not yet ready for a self-contained and consistent presentation. This book, which is based on a workshop held in 1993, brings together 15 contributions addressing different perspectives on and approaches to scenario-based system design. The authors take the position that the scenario-based view does not necessarily need to overthrow the traditional practice in system development, but can improve it. In the first chapter, K. Kuutti addresses the overall role of scenarios both historically and conceptually. He sees scenarios as supporting the transformation from an informal to a more formal view in requirements engineering. Chapter 2 focuses on design as a distributed social process in which communication among people from different disciplines plays a vital role. T. Erickson discusses two communication concepts: stories to initially explore the usage domain, and prototypes to advance the design. In his view, stories are often about atypical situations, whereas scenarios describe typical situations. J. Nielsen (chapter 3) considers usability engineering. Since projects usually do not have the resources to do everything that is desirable, there is a need for cheaper solutions. The author's point is that scenarios have the advantage of limiting usability engineering to looking at a few examples of interaction. Chapter 4, by M. Kyng, is a detailed case study of using a number of techniques under the label of “cooperative design.” Design artifacts are precisely described and are related to design activities as well as those involved. In chapter 5, J. Karat presents another case study. He focuses on illustrating how a flexible notion of scenarios is broadly useful. One of his points is that the various techniques should not be seen as being in competition, but as approaches providing different insights. J. Muller et al. (chapter 6) describe two techniques through a combination of which scenarios can be used to support the activities of heterogeneous teams: the CARD technique and the PICTIVE technique. T. Carey and M. Rusli (chapter 7) consider scenarios as a retrospective technique to enable reuse of design insights. They describe the insights gained by an in-depth analysis of usage and a graphical representation of how users employ the system's features. The next chapter has a similar concern: A. Maclean and D. McKerlie emphasize the role of design rationales and present a semiformal notation to represent the designers' thinking and reasoning. Scenarios are used both in generating a set of criteria and in relating the representation of the rationales to use-oriented representations. Chapter 9 switches over to relating scenarios and implementation aspects. P. Johnson et al. use scenarios for requirements gathering in design work with medical professionals. A main point, however, is that scenarios describe sequences of task activities carried out by users, which are then used as testbeds for prototyping. This enables users to comment on the quality and the usability of the design. Four chapters explicitly deal with the relationship between object orientation and scenarios. Object-oriented analysis and design include developing an application domain model, and scenarios may provide narrative descriptions of the appropriate information. M. B. Rosson and J. M. Carroll (chapter 10) present a tool combining the development of task scenarios with the design of an object-oriented implementation. In their approach, the users' tasks and the software implementing them are designed conjointly. At the end, the designers have runnable scenarios as well as the design documentation. In chapter 11, S. P. Robertson introduces systematic question-asking into object-oriented design. First, he uses questions to enrich the information available in initially created scenarios, and then he applies methods from natural language comprehension research to structure the information for use in an object-oriented design. Chapters 12 and 13 discuss two well-known techniques in object orientation, the use-case approach and the responsibility-driven approach, and relate them to the scenario-based technique. I. Jacobsen gives a detailed case study applying his use-case approach and argues that it differs from scenarios in that use cases are treated more formally and in that it allows use-case classes. R. Wirfs-Brock describes responsibility-driven design, the central idea behind which is to develop a model of cooperating, communicating objects. This approach is related to scenarios in that it describes software from the outside looking in and in that it prefers informal techniques for describing objects and their roles, responsibilities, and interactions. The volume ends with two discussion chapters providing an integrated view. R. L. Mack's discussion on scenarios as engines of design (chapter 14) is a particularly excellent guide to the state of the art. The chapter is arranged in an orthogonal way. Along the first dimension, the author considers developing scenarios by working with users, using scenarios effectively in design, and establishing the completeness of scenarios as specifications. The other dimension distinguishes between practical experience and theoretical foundations. In the last chapter, B. Nardi reflects on methodological issues. Some of the issues she discusses are data quality, the question of when to use scenarios, and the future of scenarios. One of the best features of this volume is the large number of case studies convincingly demonstrating the central role scenarios may play in all phases of software development. I recommend this book not only to people interested in the development of scenario-based technology, but to software engineers who want to look beyond their everyday work. Object-oriented software engineers, in particular, should benefit from the examples, since scenario-based design and object-oriented methods are complementary to one another. The casual reader may wish to focus on selected chapters; nevertheless, he or she should start by reading the final discussions. The references, given separately for each chapter, are good hints for further reading.