Home > Store > Software Development & Management > Object Technology

Patterns for Effective Use Cases

Register your product to gain access to bonus material or receive a coupon.

Patterns for Effective Use Cases

Book

  • Your Price: $27.99
  • List Price: $34.99
  • Usually ships in 24 hours.

Description

  • Copyright 2003
  • Dimensions: 7-3/8x9-1/4
  • Pages: 272
  • Edition: 1st
  • Book
  • ISBN-10: 0-201-72184-8
  • ISBN-13: 978-0-201-72184-3

Use cases have become an integral part of modeling software requirements, but many software developers are discovering that writing effective use cases is more difficult than they had anticipated. An understanding of the basic principles of use cases is not enough. Software developers need a source of objective criteria by which to judge quality and effectiveness.

Patterns for Effective Use Cases provides this set of objective criteria. Written by experienced use case practitioners, this book fills a critical information gap by presenting a pattern language that contains over thirty patterns, providing simple, elegant, and proven solutions to the most common problems in use case development. These patterns distill and define the properties and characteristics of quality use cases. As such, they facilitate the development of original use cases and provide a diagnostic tool for evaluating existing ones.

The book opens with a review of use cases and pattern fundamentals, along with a discussion of the requirements-gathering team. These patterns address the use case development process, the internal structure of use cases, and the relationships among use cases within the system as a whole. Examples of patterns include:

  • BreadthBeforeDepth
  • VisibleBoundary
  • EverUnfoldingStory
  • IntentionRevealingName
  • PreciseAndReadable
  • LeveledSteps
  • InterruptsAsExtensions
  • RedistributeTheWealth

Each pattern discussion includes at least one example demonstrating its real-world application, highlighting both the benefits of using the pattern and the consequences of not doing so. In addition, the book presents guidelines for the effective use of UML with relevant patterns.

Anyone involved in use case writing or requirements gathering will find Patterns for Effective Use Cases an indispensable handbook and reference.



0201721848B07302002

Sample Content

Online Sample Chapter

What Is a Quality Use Case?

Downloadable Sample Chapter

Click below for Sample Chapter(s) related to this title:
Sample Chapter 1

Table of Contents



Preface.


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.

The Examples.

Organization of the Pattern Catalog.

Process Patterns.

Structural Patterns.

Supplement: A Brief Tutorial on Writing Use Cases.



2. The Team.

Team organizational issues.

SmallWritingTeam(47).

ParticipatingAudience(50).

BalancedTeam(54).

Tradeoffs and Collaborations.



3. The Process.

BreadthBeforeDepth(63).

Breadth Before Depth and UML by Dan Rawthorne.

SpiralDevelopment(66).

SpiralDevelopment and UML Models by Dan Rawthorne.

MultipleForms(83).

QuittingTime(71).

TwoTierReview(76).

WritersLicense(80).

Tradeoffs and Collaborations.



4. The Use Case Set.

SharedClearVision(95).

VisibleBoundary(101).

VisibleBoundary(101) and UML Models by Dan Rawthorne.

ClearCastOfCharacters(105).

UserValuedTransactions(110).

EverUnfoldingStory(117).

EverUnfoldingStory and UML Models by Dan Rawthorne.

Tradeoffs and Collaborations.



5. The Use Case.

CompleteSingleGoal(132).

IntentionRevealingName(144).

ScenarioPlusFragments(136).

ExhaustiveAlternatives(140).

Adornments(147).

PreciseAndReadable(152).

Tradeoffs and Collaborations.



6. Scenarios and Steps.

DetectableConditions(168).

LeveledSteps(173).

VisibleActorIntent(161).

ForwardProgress(164).

TechnologyNeutral(177).

Tradeoffs and Collaborations.



7. Use Case Relationships.

CommonSubBehavior(186).

CommonSubBehaviour and UML by Dan Rawsthorne.

InterruptsAsExtensions(191).

InterruptsAsExtensions and UML by Dan Rawsthorne.

Extensions and UML Extension Points.

PromoteAlternative(196).

PromoteAlternatives and UML by Dan Rawsthorne.

Tradeoffs and Collaborations.

Supplement.

CaptureTheAbstraction — A Pattern for Applying UML Generalization by Dan Rawsthorne.

Capture the Abstraction and UML.



8. Editing Existing Use Cases.

RedistributeTheWealth(206).

MergeDroplets(211).

CleanHouse(216).

Tradeoffs and Collaborations.



Index 0201721848T05162002

Preface

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.

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, 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.

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 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.

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 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.

What About UML?

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.

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 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.

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 differing sizes, containing people having differing 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 their effectiveness on projects through particular techniques;
  • How a group of people can improve their combined effectiveness through various group techniques; and
  • Examples of particular, successful methodologies that you can use 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 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.

Pattern Heritage

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.

Future Work

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.



0201721848P05162002

Index

Click below to download the Index file related to this title:
Index

Updates

Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership