Use-case analysis

Abstract: Scenarios have been advocated as a means of improving requirements engineering yet few methods or tools exist to support scenario based RE. The paper reports a method and software assistant tool for scenario based RE that integrates with use case approaches to object oriented development. The method and operation of the tool are illustrated with a financial system case study. Scenarios are used to represent paths of possible behavior through a use case, and these are investigated to elaborate requirements. The method commences by acquisition and modeling of a use case. The use case is then compared with a library of abstract models that represent different application classes. Each model is associated with a set of generic requirements for its class, hence, by identifying the class(es) to which the use case belongs, generic requirements can be reused. Scenario paths are automatically generated from use cases, then exception types are applied to normal event sequences to suggest possible abnormal events resulting from human error. Generic requirements are also attached to exceptions to suggest possible ways of dealing with human error and other types of system failure. Scenarios are validated by rule based frames which detect problematic event patterns. The tool suggests appropriate generic requirements to deal with the problems encountered. The paper concludes with a review of related work and a discussion of the prospects for scenario based RE methods and tools.

Abstract: (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

Abstract: Object-oriented and real time together the behavioural fabric of systems a context for designing with use case maps a simple example basic use case map model case study - a conventional object-oriented application advanced use case map model case study - high level design of a real-time, distributed system detailed design notation case study - rounding out the real-time, distributed system example macro and micro patterns supplementing familiar design methods. Appendix: notation summary some coding examples.

Abstract: An approach for guiding the construction of use case specifications is presented. A use case specification comprises contextual information of the use case, its change history, the complete graph of possible pathways, attached requirements and open issues. The proposed approach delivers a use case specification as an unambiguous natural language text. This is done by a stepwise and guided process which progressively transforms initial and partial natural language descriptions of scenarios into well structured, integrated use case specifications. The basis of the approach is a set of linguistic patterns and linguistic structures. The former constitutes the deep structure of the use case specification whereas the latter corresponds to the surface structures. The paper presents the use case model, the linguistic basis and the guided process along with the associated guidelines and support rules. The process is illustrated with the automated teller machine (ATM) case study.