Patterns for Effective Use Cases

Book Description

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 for designing 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 Devel.../p>

Reviews From AMAZON.COM

Good advice but fails to address the real UC issues

This book attempts to take use cases to a higher level of science and in part succeed. Its plus points are discussions on management of use cases and the processes a team goes through in completing the creation / validation cycle. There's a lot of good sense here. Some of the patterns are useful. However, there's also a lot of regurgitation from various other texts and papers, some written by the authors themselves. And some key aspects are missing, aspects that are really important to industry and others that have concerned academia. Industry is not too worried about how to name use cases these days; that's easy. They want to be able to estimate how long it will take to build the system from use case points, for instance, or how to achieve forward traceability to the design and maintain traceability back to the requirements and business strategies (not the same thing exactly as the use case goal - which typically is not to stuff up and to make the principal actor happy). Academics are concerned too with effort estimation, with grammar and consistency checking, with dependencies and product lines, and non-functional requirements and whether use cases are at all to do with requirements in the first place and what they are no good for. Not whether we can build a little online booking web site - we can already do that. Though the book does not set out to answer these difficult questions, in its 200-odd pages, it ought to have, since this is what we really want to know about. So, though the book is excellent on what it does address, there's a lot of over kill in this. What's missing is what it does not address - all the hard problems we really need answers to.

The How, What and Why of Use Cases

Patterns for Effective Use cases is a must read if you need to develop for a software application. The authors describe what makes for a good use case, and make the points memorable with stories, and examples. If you have lots of experience writing use cases many of the patterns will cover things that you already know, but the way the patterns are presented make for an effective tool to help you teach others how to write a good use case. The pattern language format makes it clear that any single practice will not make for a good use case, you need to take a number together, otherwise you may have something that looks good at first glance, but just does not work.

I recommend this book for anyone who is learning to write use cases, or for experienced people who want a refesher course.