Table of Contents
| Foreword | |
| Preface | |
| Acknowledgments | |
| Ch. 1 | What Is a Quality Use Case? | 1 |
| Ch. 2 | The Team | 29 |
| Ch. 3 | The Process | 45 |
| Ch. 4 | The Use Case Set | 77 |
| Ch. 5 | The Use Case | 115 |
| Ch. 6 | Scenarios and Steps | 145 |
| Ch. 7 | Use Case Relationships | 173 |
| Ch. 8 | Editing Existing Use Cases | 201 |
| References | 217 |
| Photo Credits | 219 |
| Index | 223 |
Forewords & Introductions
Use cases are popular for modeling, yet people often struggle when writing them. They understand the basic concepts of use cases, but find that actually writing useful ones turns out to be harder than they expect. One factor contributing to this difficulty is that we lack objective criteria to help judge the quality of use cases. Many people find it difficult to articulate the characteristics of an effective use case.
This book examines the problems people encounter while writing use cases. It describes simple, elegant, and proven solutions to the specific problems of writing use cases on real projects. We have identified approximately three dozen patterns that professionals can use to evaluate their use cases. We have based these patterns on the observable signs of quality that successful projects tend to exhibit. Our goals are to provide a vocabulary for discussing and sharing these properties with other people, to offer advice for writing and organizing use cases effectively, and to give some "diagnostics" for evaluating use cases. We want these patterns to become second nature. Our hope is to find people saying, "Do we have a SharedClearVision?" (p. 80) or "Does this use case have a CompleteSingleGoal? (p. 118) when discussing their use cases.
Audience
This book is intended for anyone who deals with use cases and wishes to learn more about them. It assumes that you have a working knowledge of use cases, and have some experience writing them. It is the follow-up to Alistair Cockburn's Writing Effective Use Cases. If you are unfamiliar or inexperienced with use cases, then we recommend that you read Alistair's book first.
Use cases are helpful fordesigning business processes, whether based on software or not. We do not intend for this book to be yet another software development book, written in "geek-speak" that is indiscernible to all but the most technically gifted. Yet, we understand that use cases are predominantly a software development tool, and we, being software developers, cannot help but focus on this area. We hope that this book helps all the participants of a project understand the software development community; we have tried to illustrate this topic in a usable manner for all who work with use cases.
Organization
This book is organized as a catalog of approximately three dozen patterns offering criteria for evaluating the quality of use cases. Each pattern describes a specific guideline or "sign of quality" that you can use to judge the caliber of a use case in a particular area. Because each organization has its own culture and its own way of doing things, use cases that work well for one organization may completely miss the mark in another. Patterns document generalized solutions and as such provide a simple, yet effective, mechanism for describing the characteristics of quality use cases. Patterns can transcend organizational differences, allowing people to tailor the solution to their specific needs.
We document our patterns using the style of Christopher Alexander, in which we define the problem, the context in which it occurs, and a solution. We find this format to be very readable, and it is more appropriate for our topic and a diverse audience. Pattern names appear in bold type. For example, ActorIntentAccomplished (p. 158) and EverUnfoldingStory (p. 102) are both patterns described in this book. We include the page number in parentheses after the pattern name to help you locate its description.
The patterns are organized into categories. For example, Chapter 2 describes organizational patterns, Chapter 3 describes process patterns, and Chapter 4 describes the use case set patterns.
Each pattern has one or more examples demonstrating either the benefit of implementing the solution recommended by the pattern or the consequences of what happens when you don't. We based as many of these examples on live projects as we could; however, we sanitized them, to protect the companies and people involved (quite rightly), and we streamlined them for readability. Moreover, we simplified many of them because real use cases are often long and can be quite complicated, especially the ones demonstrating bad practices. We hope that you find these examples useful. You may apply some of our other patterns to these samples, and find ways to improve them.
We illustrate our patterns with a story that runs throughout the book, following a group of developers from a national travel agency as they write some use cases for their new product, the "Wings Over the World" travel reservation system. This story portrays an environment in which many of the problems described in the book can occur and therefore provides a background for discussing the patterns. The story also helps us give examples that succinctly demonstrate a pattern that may be difficult or impossible to illustrate with real examples. While the Wings Over the World examples may be contrived, they are based on our experiences, and many of the people, conversations, examples, and even the red-eye flight are composites of real events, real conversations, and real use cases.
How to Use This Book
Reading a pattern catalog cover to cover is usually not most people's idea of fun. Your first reading of this book can be either to familiarize yourself with the patterns or to serve as a tutorial for what makes a quality use case. Either way, read Chapter 1 first, which gives you the background for use cases, patterns, and the pattern categories.
If your objective is just to become familiar with the patterns, simply read the introduction of each subsequent chapter, and then read the problem, context, and solution of each pattern. If you find a pattern interesting, or particularly germane to your specific situation, then read it more closely. Don't feel that you need to understand fully one pattern before you examine another. Once you have this knowledge, you can use the book as a reference. Store it on your shelf within easy reach, so that you can look up a pattern later when you are having a problem writing a use case, or when you are reading one and something just looks wrong.
This book can also be used as a tutorial to understand the signs of quality for a well-written use case. After reading Chapter 1, skim through each chapter and read the Wings Over the World example to get a feel for the environment that gives rise to many of the problems addressed by these patterns. Read the chapter introduction to understand the pattern category and get a brief overview of each of the patterns in that chapter. Skim the patterns themselves, read the problem statement, and the solution. Take a look at the examples and make sure you understand how the pattern improves the quality of the use case or the process to create the use case.
A great approach to learning these patterns is to hold "brown-bag" or "lunch-and-learn" sessions, which many people use to learn patterns. To do this, have someone present one or two patterns at a lunchtime seminar every week. Next, discuss the pattern, its intention, and its trade-offs. Then look at the examples, and talk about how they compare with your organization's use cases.
What about UML?
The Unified Modeling Language (UML) is the software industry's latest attempt to sign a modeling language nonproliferation treaty with itself. When most people think of use cases and UML they simply think of diagramming tools. Others think of UML as defining semantics for constructs such as includes or extends. Some are UML enthusiasts, and others are not. One thing on which we all agree is that rigidly following UML semantics does not guarantee quality use cases. Many people who have never even heard of UML write great use cases. However, UML is an important influence on use cases and therefore we have included guidelines for the effective use of UML with the relevant patterns.
Why Don't We Use a Single Use Case Template for the Examples?
With the exception of the Wings Over the World use cases, most of the use cases presented throughout this book are sanitized versions of real production use cases. Many of these use cases appear different because they are the work of different writers. We chose not to create a uniform template to present all the examples because we did not want to advocate a specific use case template. There are enough around now, and just as we did not want to imply there is only one true way to write a use case, we also did not want to imply there is only one true use case template.
We chose to use different styles for our use case diagrams for the same reason, employing a variety of different drawing and Computed-Aided Software Engineering (CASE) tools to generate them.
The Agile Software Development Series
This book is one in a collection of books, the Agile Software Development Series, that highlights light, human-powered software development techniques. Some books discuss a single technique, some a single role on the project, and some discuss team collaboration issues.
The book series is based on two common principles:
- Different projects have different needs. Systems have different characteristics and are built by teams of various sizes, containing people having diverse values and priorities. It cannot be possible to describe the one, best way of producing software.
- Focusing on skills, communication, and community allows the project to be more effective and more agile than focusing on processes and plans.
Accordingly, the book series runs along three main tracks:
- How one person can improve his or her effectiveness on projects through particular techniques;
- How a group of people can improve their combined effectiveness through various group techniques; and
- How particular examples of successful methodologies can serve as models for your own adaptations.
- Agile Software Development elaborates the ideas of software development as a cooperative game, of methodology as coordination of culture, and of methodology families. It separates the different aspects of methodologies: techniques from activities, work products and standards.
- Agile Software Development Ecosystems discusses problems in software development, principles that unite in common across the diverse experts in the Agile Alliance, a group of people who wrote the Manifesto for Agile Software Development, and common agile practices.
- Writing Effective Use Cases is a technique guide, describing the nuts and bolts of use case writing. Although you can use the techniques on almost any project, the templates and writing standards must be selected according to the needs of each individual project.
- Patterns for Effective Use Cases is a handbook for writing high-quality use cases, providing a set of patterns for gauging the quality of use cases, and offering suggestions for improvement when your use cases fail to meet them. You can apply the concepts from this follow-up to Writing Effective Use Cases to all types of use cases, regardless of your organization's style.
- Among the other books in the series, Improving Software Organizations and Surviving Object-Oriented Projects (SOOP) are in the line of group techniques, and Crystal Clear (CC) is in the line of sample methodologies.
Pattern Language Heritage
Paul Bramble began researching the concept of use case patterns in the summer of 1997, after receiving numerous suggestions from his colleague Linda Rising (author of The Pattern Handbook Rising 1998 and The Pattern Almanac Rising 2000). He had been defining a generic use case development process for their company when he realized that use cases are highly dependent on the personalities of the group using them. Recognizing that this research required the input of multiple people and experiences, he co-organized a workshop on use case patterns with Alistair Cockburn at OOPSLA 98 in Vancouver, British Columbia. Eleven participants attended the workshop, and four of them (Paul, Alistair, Andy Pols, and Steve Adolph) agreed to continue the research. It took them well over two years to define their use case pattern language, requiring several meetings in the western United States and Canada, as well as two ChiliPLoP conferences to workshop several of their patterns.
We know that there are many more potential patterns out there that people use every day--whether they are conscious of it or not--to create high quality use cases. We sincerely hope this book helps to inspire debate and motivate others to capture these patterns.
loading...