Use Case Modeling

The director for Requirements Management Solutions at Rational Software, Kurt Bittner served on the original Rational Unified Process development team. He has twenty years of experience in software development, including work in requirements capture, analysis, design, development, and project and product management. A senior consultant at Rational Software, Ian Spence specializes in the adoption of the Rational Unified Process and the use case driven approach that it recommends. He has over eighteen years of experience in the software industry, covering the complete development lifecycle, including requirements capture, architecture, analysis, design, implementation, and project management. 0201709139AB08062002

(NOTE: Each chapter concludes with a Summary.)

Foreword.


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.



Use-Case Diagrams.



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.



Actors.



Use Cases.



Connecting Actors and Use cases.



Use-Case Diagrams.



Brief Descriptions.



Use-Case Descriptions.



Supporting Artifacts.



The Glossary and/or the Domain Model.



Supplementary Specifications.



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.


Finding Actors.



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.



Documenting Actors.



How to Name Actors.



Don't Confuse Actors with Organizational Roles or Job Titles.



Don't Overgeneralize.



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



Identify Use Cases.



Consolidate the Model and Validate the Results.



Wrap Up the Workshop and Plan the Next Steps.



Supporting Activities.



Capture Terminology in a Glossary.



Capture Nonfunctional Requirements.



Capture Issues, Risks and Assumptions.



Handling Common Problems.



Avoid Functional Decomposition and Dataflow Modeling.



Maintain Focus.



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.



Team Working.



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?



Getting Started.



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.



Managing Detail.



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?



Describing Preconditions.



Deciding Whether a Precondition Is Needed.



Describing Preconditions.



Describing Postconditions.



Deciding Whether Post Conditions Are Needed.



Describing Postconditions.



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.



Informal Reviews.



Formal Reviews.



What to Review, and When to Review it.



Who Should Review the Use Cases.



Understanding the Audience.



Setting Expectations.



Preparing for the Review.



Running the Review Meeting.



Handling Issues.



What to Look For When Reviewing.



Reviewing Diagrams.



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.



What's Next?

Appendix.
Glossary.
Bibliography.
Index. 0201709139T08062002