Use cases have become a very popular requirements-gathering technique, yet many developers struggle when faced with writing them. They grasp the basic concepts, but find that writing effective use cases turns out to be more difficult than they expected. One factor contributing to this difficulty is that the community lacks objective criteria for judging the quality of use cases. This new book articulates the qualities of effective use cases by applying the proven patterns concept of development to this requirements-gathering technique. The authors present a catalog of thirty-six patterns that help the reader become proficient at judging the quality of their (and other's) patterns. These patterns represent solutions to recurring problems that application developers have faced in writing use cases. Each pattern is presented with examples that help the reader understand the benefit of the pattern, and just as importantly, the consequences of ignoring its proper use.
Click below for Sample Chapter(s) related to this title:
Sample Chapter 1
1. What is a Quality Use Case?
Why Use Cases at All?
What's So Hard About Telling Good Stories?
Why a Use Case Pattern Language?
What are Patterns.
How Should I use this Pattern Language.
What is he Use Case Pattern Form?
Stepping Through a Sample Pattern.
Organization of the Pattern Catalog.
Supplement: A Brief Tutorial on Writing Use Cases.
Team organizational issues.
Tradeoffs and Collaborations.
Breadth Before Depth and UML by Dan Rawthorne.
SpiralDevelopment and UML Models by Dan Rawthorne.
Tradeoffs and Collaborations.
VisibleBoundary(101) and UML Models by Dan Rawthorne.
EverUnfoldingStory and UML Models by Dan Rawthorne.
Tradeoffs and Collaborations.
Tradeoffs and Collaborations.
Tradeoffs and Collabora
Use cases are a popular requirements modeling technique, 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 one would expect. One factor contributing to this difficulty is that we lack objective criteria to help judge their quality. Many people find it difficult to articulate the qualities 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 people 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, provide advice for writing and organizing use cases effectively, and provide 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(95)?" or "Does this use case have CompleteSingleGoal(132)?" when discussing their use cases.
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, software based 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, and readable only by the most determined. Yet, we understand that use cases are predominately 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, and we have tried to illustrate this topic in a usable manner for all who work with use cases.
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 and yet effective mechanism for describing the characteristics of quality use cases. As such, 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 is more appropriate for our topic and diverse audience. Pattern names appear in bold type. For example, VisibleActorIntent(161) and EverUnfoldingStory(117) are both patterns described in this book. We include the page number in parenthesis after the pattern name to help you locate its description.
The patterns are organized into categories. For example, chapter two describes organizational patterns, chapter three describes process patterns, and chapter four 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), as well as 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 provide 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.
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 serve as a tutorial for what makes a quality use case. Either way, read chapter one, 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 fully understand 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 have a problem writing a use case, or 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 one, 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. Then discuss the pattern, its intention and its tradeoffs, then look at the examples, and discuss how they compare with your organization's use cases.
The Unified Modeling Language is the software industry's latest attempt to sign a modeling language non-proliferation treaty with itself. When most people think of use cases and UML they simply think of diagramming tools. Others think about UML defining semantics for include and extends in UML parlance. 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.
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 works of different writers. We could have created a uniform template to present all the examples, but we decided not to 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, using a variety of different drawing and CASE tools to generate them.
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:
Accordingly, the book series runs along three main tracks:
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 Ecologies discusses problems in software development, principles that are found in common across the diverse experts in the Agile Alliance, 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.
Guidelines for Writing 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.
Paul Bramble began researching the concept of Use Case Patterns in the summer of 1997, after numerous suggestions from his colleague Linda Rising (author of The Pattern Handbook and The Pattern Almanac). 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, BC. 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.
Click below to download the Index file related to this title: