PRODUCT SUPPORT ANNOUNCEMENT
See the latest about COVID-19 shipping availability and video/Web Edition load errors. Learn more.
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.
Click below for Sample Chapter(s) related to this title:
Sample Chapter 6
(NOTE: Each chapter concludes with a Summary.)
Preface: Why Bother with Use Cases?
What Are “Use Cases” All About?
Who Should Be Interested in Use Cases?
How to Read This Book.
I. GETTING STARTED WITH USE CASE-MODELING.1. A Brief Introduction to Use-Case Modeling.
Actors and Use Cases.
The Relationship Between Use Cases and Requirements.
Types of Requirements.
Functional and Nonfunctional Requirements.
The Role of Use Cases.
Use Cases Place Software Requirements in Context.
To “Use Case” or not to “Use Case”.
When Are Use Cases Useful?
Use Cases Provide a Conceptual Model of the System.
Use Cases Describe How the System Is Used and What It Does for Its Stakeholders.
Does Everything the System Does Have to Be Described in a Use Case?
General Principles of Use-Case Modeling.
Use Cases Do Not Exist In Isolation.
Use Cases Are a Synthetic Rather Than an Analytic Technique.
Rules of Thumb.2. Fundamentals of Use Case Modeling.
The Use-Case Model.
The Basic Building Blocks of a Use-Case Model.
Connecting Actors and Use cases.
The Glossary and/or the Domain Model.
Declarative and Special Requirements.3. Establishing the Vision.
Introducing Stakeholders and Users.
What Are Stakeholders?
The Role of Stakeholders and Stakeholder Representatives.
Users: A Very Important Class of Stakeholder.
Stakeholders and Use-Case Modeling.
Involving Stakeholders and Users In Your Project.
Step 1: Identify Stakeholder and User Types.
Step 2: Identify and Recruit the Stakeholder Representatives.
Step 3: Involve the Stakeholder Representatives in the Project.
Creating a Shared Vision.
Analyze the Problem.
Understand the Key Stakeholder and User Needs.
Describe the Features and Other High-Level Product Requirements.
Provide an Overview of the Product.
Bringing It All Together: The Vision Document.
Do You Really Need To Do All Of This?4. Finding Actors and Use Cases.
Start by Identifying the Primary Actors.
Work from the Specific to the General.
Don't Forget the Supporting Actors.
Consider All Existing Requirements Information.
Remember That Actors Are Not Always People.
Focus on the System Boundary.
Identify the information sources.
Don't Preempt the Design.
Don't Confuse the Actors with the Devices They Use.
When you Can't Find the Actors, Start with the Use Cases.
Focus First on the Familiar.
Evolve the Set of Actors Alongside the Set of Use Cases.
How to Name Actors.
Don't Confuse Actors with Organizational Roles or Job Titles.
Give Every Actor a Brief Description.
Characterize the Actors.
Trace the Actors to the User Types, Stakeholders, and Stakeholder Roles.
Finding Use Cases.
Start by Identifying the Actor Goals.
Consider the Information Needs of the System and Its Users.
Don't Worry About Commonality (at least at first).
Don't Confuse Use Cases with “Functions”.
Focus on Value.
Derive the Use Cases from the System's Vision.
Don't Forget the Supporting and Operational Use Cases.
Evolve the Set of Use Cases Alongside the Set of Actors and the Supplementary Specification.
Documenting Use Cases.
Associate the Use Cases to their Actors.
Name the Use Cases.
Give every Use Case a Brief Description.
Outline the Use Cases.
Trace the Use Cases to Stakeholders and Stakeholder Roles.
Trace the Use Cases to the Features and Constraints.5. Getting Started With A Use Case Modeling Workshop.
Reasons for Having a Workshop.
To Transfer Expertise.
To Build a Team.
To Create Shared Understanding.
To Tap into the Creative Power of a Group.
Preparing for the Workshop.
Train the Participants.
Understand the Vision.
Keep the Group Small and Involved.
Vary the Composition of the Group.
Select a Facilitator.
Set Objectives for the Workshop.
Schedule the Workshop and Organize the Facilities.
Finding a Mentor.
Find an Effective Communicator.
Find a Skilled Motivator and Manager.
Find a Mentor with Full Lifecycle Experience.
Don't Use the Mentor as a Crutch.
Structuring the Workshop.
Define the Ground Rules for the workshop.
Understand the Problem.
Define the Boundary of the System.
Identify Use Cases.
Consolidate the Model and Validate the Results.
Wrap Up the Workshop and Plan the Next Steps.
Capture Terminology in a Glossary.
Capture Nonfunctional Requirements.
Capture Issues, Risks and Assumptions.
Handling Common Problems.
Avoid Functional Decomposition and Dataflow Modeling.
Synthesize, Don't Analyze.
Don't Describe What Happens Outside the System.
Don't Just Draw Pictures.
Don't Mix Business Use Cases and System Use Cases.6. The Lifecycle of a Use Case.
The Software Development Life Cycle.
The Authoring Life Cycle.
State 1: Discovered.
State 2: Briefly Described.
State 3: Bulleted Outline.
State 4: Essential Outline.
State 5: Detailed Description.
State 6: Fully Described.
The Use-Case Modeling Process.
Establish the Vision.
Produce an Overview of the System.
Reach Agreement on System Scope.
Package the Use-Case Model.
Address Areas of Instability and Author Stable Use Cases and Supplementary Specifications.
Consolidate and Review the Use-Case Model.
II. WRITING AND REVIEWING USE-CASE DESCRIPTIONS.7. The Structure and Contents of a Use Case.
Use Cases and System State.
The System and External Events.
The System State: More about Preconditions and Postconditions.
How Use Cases Interact.
The SideEffects of Using PreConditions.
The Nature of the Flow of Events.
The Structure of the Flow of Events.
Managing Scope Using Alternative Flows.
The Complexity of the Use-Case Model Versus the Complexity of the Design.
Visualizing the Flow of Events.
What Is a Scenario?
What Is a Use-Case Realization?8. Writing Use-Case Descriptions: An Overview.
Who Writes Use-Case Descriptions?
Programmers Write Poor Descriptions.
The Characteristics of a Good Use-Case Author.
How Long Does It Take to Write a Use Case?
Use a Style Guide.
Write Simply, Directly and Deliberately.
Treat the Use Case Like a Story.
Make a Conscious Decision about the Depth of Detail Required.
Describe What Happens When the Actors and the System Interact.
Don't Rely on Just Text.
Prototype the User Interface.
Good Use-Case Models Have No “Levels”.
Adapt the Description to Your Intended Audience.
Use the Glossary and Domain Model to Capture Definitions.
Capture Business Rules in a Domain Model.
Use Subflows to Simplify Complex Descriptions.
Use Alternative Flows to Capture Unusual or Complex Behavior.
Don't Fill Your Use Cases with CRUD.
Don't Be Afraid of Capturing the Detail.9. Writing Use-Case Descriptions: Revisited.
How Much Detail Is Enough?
Deciding Whether a Precondition Is Needed.
Deciding Whether Post Conditions Are Needed.
Writing The Flow of Events.
Writing the Basic Flow of Events.
Pay Attention to What's Behind the Screen.
Using the Glossary and the Domain Model.
Writing “Named” Subflows.
Writing Optional, Alternate and Exception Flows.
Identifying Alternative Flows.
Representing Alternative Flows in Separate Sections.
Naming Alternative Flows.
Using Extension Points to Target Alternative Behavior.
Describing Alternative Flows That Can Occur Anywhere in the Use Case.
Resuming the Use Case After the Alternative Flow Completes.
Alternative Flows for Alternative Flows and Named Subflows.
Writing Special and Supplementary Specifications.
Capturing Use-Case Scenarios.10. Here There Be Dragons.
Using Named Subflows and Alternate Flows to Structure Text.
Defining Relationships Between Use Cases.
Using the Include Relationship.
Common Errors Using the Include Relationship.
Using the Extends Relationship.
Extension Points, Revisited.
Evaluating the Resulting Use-Case Model.
Using Generalization between Use Cases.
Defining Relationships Between Actors.11. Reviewing Use Cases.
Why Focus on Presenting and Reviewing Use Cases?
Types of Reviews.
What to Review, and When to Review it.
Who Should Review the Use Cases.
Understanding the Audience.
Preparing for the Review.
Running the Review Meeting.
What to Look For When Reviewing.
Reviewing Brief Descriptions.
Reviewing Use-Case Descriptions.
Reviewing Preconditions and Postconditions.
Reviewing the Glossary and Domain Model.
The Role of Prototypes and Storyboards in Use-Case Reviews.12. Wrapping-Up.
Use Cases and the Project Team.
Developers and Use Cases.
Testers and Use Cases.
Use Cases and the User Experience.
Use Cases and Documentation.
Managers, Use Cases and Planning.
Use Cases Across the Lifecycle.
Use Cases and Iterative Development.
Use Cases in the Inception Phase.
Use Cases in the Elaboration Phase.
Use Cases in the Construction and Transition Phases.
Use Cases after Product Release.
Traceability, Completeness and Coverage.
In a world where it seems we already have too much to do, and too many things to think about, it seems the last thing we need is something new that we have to learn. As Eric Sevareid observed, the chief cause of problems is solutions.
But use cases do solve a problem with requirements: with strict declarative requirements it's hard to describe steps and sequences of events. To see why, 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 we charge the ATM usage fee before or after we check for overdraft? If the customer's account balance is less than the ATM usage fee, charging the ATM usage fee before we check 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 us to describe the sequences of events that, taken together, lead to a system doing something useful. As simple as this sounds, 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 example above, use cases reduce the ambiguity of the requirements by specifying exactly when and under what conditions certain behavior occurs; as such, we can regard the sequence of the behaviors 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 on declarative requirements and shall statements, completely fail to capture the dynamics of the system's behavior. Use cases give us a simple yet powerful way to express the behavior of the system in way that all stakeholders can easily 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.
The short answer to this question is just about everyone, or at least everyone involved in some aspect of delivering a system that satisfies the needs of the 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 system behavior:
This book is fundamentally about creating use-case models, and more importantly about writing the detailed descriptions of use cases. To remain focused on this task, we have intentionally left out the parts of the project lifecycle 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 person who is actually doing the work and grappling with the unique problems of working with Use Cases. It can certainly be read cover-to-cover, but the real intent behind the book is to provide you with something that can continue to add value after the first reading, providing you with a mentor at your fingertips. The topics presented in the book have arisen from working with countless 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 that you 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 use cases: with a workshop.
The first chapter, A Brief Introduction to Use Cases, provides practical background for people who are unfamiliar with use cases, or for people who have read other books and articles and still find themselves wrestling with the basic ideas. The purpose of the chapter is to provide a brief overview of the use case approach without getting into a lot of formal details.
The second chapter, Fundamentals of Use Case Modeling, presents the foundations underlying the use case modeling technique. The concepts presented here will provide the basis for the subsequent chapters in the book.
The third chapter, Establishing the Vision, provides us with the essential tools for determining the business problem we are solving, for identifying the stakeholders in the solution, and for deciding what the system should do for those stakeholders to solve the business problem. This information is essential if we are to define the right solution when we develop our use case model.
The fourth chapter, Finding Actors and Use Cases, describes the process and subtleties of identifying the key elements of the use case model. The purpose of this content is to help you through the sometimes-confusing task of getting started by providing a sound understanding of the basic concepts of actors and use cases.
The fifth chapter, Getting Started with a Use-Case Modeling Workshop, describes the practicalities of getting started using use cases, including how to run a use-case workshop and how to deal with the practical details of starting to work with use cases.
In Part II, Writing and Reviewing Use Case Descriptions, we explore the finer details of working with use cases, including the anatomy of a use case, how to write use-case descriptions (instead of the simple but incomplete descriptions presented in Part I), and what it means to work with use cases in practice. In these chapters, we explore in-depth how to write detailed use-case descriptions.
The sixth chapter, The Lifecycle of a Use Case, describes the transitions that a use case undergoes as it evolves from concept to complete description. This chapter establishes context for the remaining chapters, as well as placing the content of Part I into a larger context.
The seventh chapter, The Structure and Contents of a Use Case, describes the various constituent parts of a use case -- the basic flow, preconditions, post-conditions, and the alternate flows, as well as related topics.
The eighth chapter, Writing Use Case Descriptions - An Overview, describes the objectives and challenges related to writing detailed descriptions of use cases, and presents strategies for successfully mastering this challenging task.
The ninth chapter, Writing Use Case Descriptions -- Revisited, discusses the mechanics of how to go about writing use-case descriptions, how to handle details, and how to structure the descriptions for readability. This is done using an evolving example in which a variety of techniques are progressively and systematically applied to improve the quality of the use-case description.
The tenth chapter, Here There Be Dragons, describes the problems that most teams encounter when using relationships between use cases (specifically the include, extend and generalization relationships) and relationships between actors.
The eleventh chapter, Reviewing Use Cases, describes how to organize and conduct reviews of the use case model, including a summary of areas where particular focus is needed.
The final chapter, chapter twelve -- Wrapping Up, touches on a number of topics related to how use cases are used in the larger context of the project, bringing our journey into the world of use cases to a close. In doing so, we provide the reader with a number of references to sources to consult for further information about how use cases are used in other disciplines.
We have had the pleasure, over the years, to work with many colleagues and customers who have helped shape the views that are presented here. A full enumeration of all of these people would be impossible, but we find ourselves especially indebted to a number of our colleagues for contributing to our views on use cases. We are in great debt to Ivar Jacobson, who originated the concepts of use case modeling and initially defined their role in the modern software development process, for his support and encouragement on this project. We are also indebted to our colleague Dean Leffingwell for his work defining the role of use cases and traditional requirements management approaches. 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 the long evolution of this book.
Special thanks go to Douglas Bush and Ida Audeh for their assistance in helping us to write clearly and concisely. We would also like to thank the many technical consultants at Rational whose experiences and questions have helped to shape this book. Finally, we would like to thank the customers with whom we and these consultants have worked, since their experiences and questions have ultimately made us realize that this book has been 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
Use cases have come a long way since I first proposed them in 1986. Their value and power were clearly revealed by Object-Oriented programming. Use cases both contributed to and benefited from the development of the Object- Oriented paradigm. Today, knowledge of use cases is critical to one's understanding and application of UML and other modern software processes, such as the Rational Unified Process (RUP).
When used effectively, use cases have proven particularly valuable as part of the requirements activities of the software process. They have vastly improved communication between development teams and stakeholders and have made the determination of requirements far easier and more precise. Use cases are unique in their ability to help teams understand the value the system must provide for its stakeholders. Because use cases describe how users use the system and what the system does for those users, they provide a unique way to build consensus about what the system must do. Building consensus is essential to a project's success: If the stakeholders cannot agree on the value the system must deliver, it is unlikely that the project can be successful.
Because use cases help create this understanding, they naturally provide an excellent principle around which to structure project activities. Use cases play an important role for analysts, who work with the requirements of the system; developers, who apply use cases to design and develop the system; testers, who verify that the system delivers the value demanded by the stakeholders; technical writers, who document how the system is used; and user-experience professionals, who help to make the system easy to use. All these project team members must understand use cases in order to develop better solutions.
To date, there has been something missing from the literature of use-case modeling: a description of the practical, day-to-day details of identifying and describing use cases. This book provides those details, defining the use-case model and fleshing out use-case descriptions. It's a perfect extension and complement to my earlier works, finishing the story of how the use cases are identified and how they evolve.
Use Case Modeling builds on the basic concepts by leveraging the practical experience that Kurt and Ian have gained through their many years of work in various industries--working with development teams either as consultants or as team members themselves. They have nicely distilled that experience into this very practical and insightful work. For people new to the field, this book provides an excellent tutorial. For use-case veterans, it provides an excellent reference that can be called upon on a daily basis.
This is the very best book on use cases ever written. Read it to understand use-case ideas and to apply those ideas with common sense based on the kind of system you are building and the maturity of your team members.
Click below to download the Index file related to this title: