In a world where it seems we already have too much to do, and too manythings to think about, it seems the last thing we need is something new thatwe have to learn. As Eric Sevareid observed, the chief cause of problems issolutions.
But use cases do solve a problem with requirements: with strict declarativerequirements it's hard to describe steps and sequences of events. To seewhy, let's consider a simple example:Example
Some requirements that must be satisfied by an automated teller system:
Simple enough, you say. Or is it?
In what order should these things be done? Does it matter? If the ATM is not one that is owned by the customer's financial institution, should the ATM usage fee be charged before or after checking for overdraft? If the customer's account balance is less than the ATM usage fee, charging the ATM usage fee before checking for overdraft will automatically result in an overdraft charge being applied, even if the customer decides to cancel the transaction. Is this the right behavior? With only declarative requirements, which is all that many projects have, it's impossible to say.
Use cases, stated simply, allow description of sequences of events that,taken together, lead to a system doing something useful. As simple as thissounds, this is important. When confronted only with a pile of requirements, it's often impossible to make sense of what the authors of the requirements really wanted the system to do. In the preceding example, use cases reduce theambiguity of the requirements by specifying exactly when and under whatconditions certain behavior occurs; as such, the sequence of the behaviors canbe regarded as a requirement. Use cases are particularly well suited to capturing these kind of requirements. Although this may sound simple, the fact is that conventional requirement capture approaches, with their emphasis ondeclarative requirements and "shall" statements, completely fail to capturethe dynamics of the system's behavior. Use cases are a simple yet powerfulway to express the behavior of the system in way that all stakeholders caneasily understand.
But, like anything, use cases come with their own problems, and as useful as they are, they can be misapplied. The result is something that is as bad, if not worse, than the original problem. Therein lies the central theme of this book--how to utilize use cases effectively without creating a greater problem than the one you started with.WHO SHOULD BE INTERESTED IN USE CASES?
The short answer to this question is "just about everyone," or at least everyoneinvolved in some aspect of delivering a system that satisfies the needs ofthe customer. To be more specific about who should be interested in use cases,the following roles can benefit from the use-case technique of describing systembehavior:
This book is fundamentally about creating use-case models and, more importantly,about writing detailed descriptions of use cases. To remain focused onthis task, we have intentionally left out the parts of the project life cycle that use the use cases but are not directly involved in writing them. These areas include user-interface design, analysis, design, technical writing, testing, and project management. Other authors have covered a number of these areas adequately, and we felt that you, the reader, were best served if we focused narrowly on the use cases themselves. We hope you will agree.This book is intended to be a ready reference for the practitioner, the personwho is actually doing the work and grappling with the unique problemsof working with use cases. It can certainly be read cover to cover, but the realintent behind the book is to provide you with something that can continue toadd value after the first reading, providing you with a "mentor" at your fingertips. The topics presented in the book have arisen from working withcountless project teams who grappled with the same issues facing you.
The book is divided into two parts. In Part I, Getting Started with Use-Case Modeling, we introduce the basics concepts of use-case modeling thatyou will need to understand in order to be effective using use cases. We conclude Part I with a description of an excellent way to get started with usecases: with a workshop.
In Part II, Writing and Reviewing Use-Case Descriptions, we explore thefiner details of working with use cases, including the anatomy of a use case,how to write use-case descriptions (instead of the simple but incompletedescriptions presented in Part I), and what it means to work with use cases inpractice. In these chapters, we explore in-depth how to write detailed use-casedescriptions.
We have had the pleasure over the years to work with many colleagues andcustomers who have helped shape the views that are presented here. A fullenumeration of all of these people would be impossible, but we find ourselvesespecially indebted to a number of our colleagues for contributing to ourviews on use cases. We are in great debt to Ivar Jacobson, who originated theconcepts of use-case modeling and initially defined their role in the modernsoftware development process, for his support and encouragement on thisproject. We are also indebted to our colleague Dean Leffingwell for his workdefining the role of use cases and traditional requirements-managementapproaches. We would also like to thank Bryon Baker, Chris Littlejohns,Anthony Kesterton, Gary Evans, Laurent Mondamert, Peter Eeles, Brian Kerr,and Susan August for their insightful suggestions at various points in thelong evolution of this book. Special thanks go to Douglas Bush and Ida Audehfor their assistance in helping us to write clearly and concisely. We would alsolike to thank the many technical consultants at Rational whose experiencesand questions have helped to shape this book. Finally, we would like to thankthe customers with whom we and these consultants have worked, since theirexperiences and questions have ultimately made us realize that this book hasbeen sorely needed. To all these people goes a great share of the credit for this book; any flaws or shortcomings are exclusively our own.
Kurt Bittner and Ian Spence
Developers who effectively employ use cases deliver better applications--on time and under budget. The concept behind use cases is perhaps as old as software itself; they express the behavior of systems in terms of how users will ultimately interact with them. Despite this inherent simplicity, the use case approach is frequently misapplied, resulting in functional requirements that are confusing, cumbersome, or redundant.
In Use Case Modeling, experienced use case practitioners Kurt Bittner and Ian Spence share their tips and tricks for applying use cases in various environments. They delve into all aspects of use case modeling and management, demonstrating how development teams can capitalize on the approach's simplicity when modeling complex systems.
In this ready reference, readers will discover how to
The book draws extensively on best practices developed at Rational Software Corporation, and presents real-life examples to illustrate the considerable power of use case modeling. As such, Use Case Modeling is sure to give development teams the tools they need to translate vision and creativity into systems that satisfy the most rigorous user demands.