Use Case Diagram

About: Use Case Diagram is a research topic. Over the lifetime, 1055 publications have been published within this topic receiving 13135 citations.

Writing Effective Use Cases

Abstract: From the Publisher: Writing use cases as a means of capturing the behavioral requirements of software systems and business processes is a practice that is quickly gaining popularity. Use cases provide a beneficial means of project planning because they clearly show how people will ultimately use the system being designed. On the surface, use cases appear to be a straightforward and simple concept. Faced with the task of writing a set of use cases, however, practitioners must ask: "How exactly am I supposed to write use cases?" Because use cases are essentially prose essays, this question is not easily answered, and as a result, the task can become formidable. In Writing Effective Use Cases, object technology expert Alistair Cockburn presents an up-to-date, practical guide to use case writing. The author borrows from his extensive experience in this realm, and expands on the classic treatments of use cases to provide software developers with a "nuts-and-bolts" tutorial for writing use cases. The book thoroughly covers introductory, intermediate, and advanced concepts, and is, therefore, appropriate for all knowledge levels. Illustrative writing examples of both good and bad use cases reinforce the author's instructions. In addition, the book contains helpful learning exercises—with answers—to illuminate the most important points. Highlights of the book include: A thorough discussion of the key elements of use cases—actors, stakeholders, design scope, scenarios, and more A use case style guide with action steps and suggested formats An extensive list of time-saving use case writing tips Ahelpful presentation of use case templates, with commentary on when and where they should be employed A proven methodology for taking advantage of use cases With this book as your guide, you will learn the essential elements of use case writing, improve your use case writing skills, and be well on your way to employing use cases effectively for your next development project.

Uml Components: A Simple Process for Specifying Component-Based Software

Abstract: Foreword. 1. Component Systems. Component Goals. Component Principles. Component Forms. Example: Microsoft Word. What a Component Isn't. Component and System Architectures. System Architectures. Component Architectures. Specifying Contracts. Usage Contracts. Realization Contracts. Interfaces versus Component Specifications. Model Levels. Summary. 2. The Development Process. Workflows. The Impact of the Management Process. The Evolution of Software Processes. Accommodating Change. Workflow Artifacts. The Specification Workflow. Component Identification. Component Interaction. Component Specification. Summary. 3. Applying UML. Why Do We Need This Chapter at All? Tools. Extending UML with Stereotypes. Precision, Accuracy, and Completeness. UML Modeling Techniques. Business Concept Model. Use Case Model. Use Case Diagrams. Use Case Descriptions. Use Case Instances. Inclusions, Extensions, and Variations. Business Type Model. Types. Structured Data Types. Interface Type. Invariants. Interface Specification. Interface Specification Package. Information Model. Operation Specification. Component Specification. Component Object Interaction. Specification, Not Implementation. Component Architectures. Summary. 4. Requirements Definition. Business Processes. Business Concept Model. System Envisioning. Use Cases. Actors and Roles. Use Case Identification. Use Case Descriptions. Quality of Service. Summary. 5. Component Identification. Identifying Interfaces. Identifying System Interfaces and Operations. Make a Reservation. Take Up Reservation. Identifying Business Interfaces. Create the Business Type Model. Refine the Business Type Model. Define Business Rules. Identify Core Types. Create Business Interfaces and Assign Responsibilities. Allocating Responsibility for Associations. Creating Initial Interface Specifications. Existing Interfaces and Systems. Component Specification Architecture. System Component Specifications. Business Component Specifications. An Initial Architecture. Summary. 6. Component Interaction. Discovering Business Operations. Some Simple Interactions. Breaking Dependencies. Maintaining Referential Integrity. Component Object Architecture. Controlling Intercomponent References. Completing the Picture. Refining the Interfaces. Factoring Interfaces and Operations. Summary. 7. Component Specification. Specifying Interfaces. Operation Specification. Interface Information Models. Pre- and Postconditions. A Systematic Process. From Business Type Model to Interface Information Model. Invariants. Snapshots. Exactly What Does a Postcondition Guarantee? Specifying System Interfaces. Business Rule Location. Specifying Components. Offered and Used Interfaces. Component Interaction Constraints. Inter-Interface Constraints. Factoring Interfaces. Summary. 8. Provisioning and Assembly. What Do We Mean by Target Technology? Components Realize Component Specifications. Realization Mappings and Restrictions. Operation Parameters. Error and Exception Handling Mechanisms. Interface Inheritance and Interface Support. Operation Sequence. Interface Properties. Object Creation. Raising Events. Application Architecture Correspondence. Business Components. Subcomponents. Integrating Existing Systems. Purchasing Components. Assembly. Summary. A Final Thought. References. Index. 0201708515T04062001

Doing Hard Time: Developing Real-Time Systems With Uml, Objects, Frameworks, and Patterns

Abstract: (Chapters begin with an Introduction and conclude with a Summary, Looking Ahead, Exercises and References.) Figure List. About the Author. Preface. Acknowledgments. SECTION 1: BASICS. 1. Introduction to Objects and the Unified Modeling Language. Advantages of Objects. Terms and Concepts. Object Orientation with UML. Objects. Attributes. Behavior. Messaging. Responsibility. Concurrency. Objects as Autonomous Machines. Class Diagrams. Relations Among Classes and Objects. Use Cases. Sequence Diagrams. Physical Representation. Things Common to Diagrams. Notes. Packages. Constraints. Stereotypes. 2. Basic Concepts of Real-Time Systems. What is Real-Time? Terms and Concepts. Timeliness. Responsiveness. Concurrency. Scheduling Concurrent Threads. Event Arrival Patterns. Thread Rendezvous Patterns. Sharing Resources. Predictability. Memory Management. Correctness and Robustness. Deadlock. Exceptional Conditions. Race Conditions. Distributed Systems. Fault Tolerance and Safety. Dealing with Resource-Limited Target Environments. Low-Level Hardware Interfacing. Real-Time Operating Systems. Scalability. Scheduling. Typical RTOS Features. 3. Basic Concepts of Safety-Critical Systems. Introduction to Safety. The Therac-25 Story. Other Stories. Terms and Concepts. Safety Related Faults. Safety is a System Issue. Random Faults Versus Systematic Faults. Single Point Failures. Common Mode Failures. Latent Faults. Fail-Safe State. Achieving Safety. Safety Architectures. Single Channel Protected Design. Eight Steps to Safety. Step 1: Identify the Hazards. Step 2: Determine the Risks. Step 3: Define the Safety Measures. Step 4: Create Safe Requirements. Step 5: Create Safe Design. Step 6: Implementing Safely. Step 7: Assure Safety Process. Step 8: Test, Test, Test. Few Safety Related Standards. 4. Rapid Object-Oriented Process for Embedded Systems. Terms and Concepts. Development Phases. Ordering. Maturity. Development Task Sequencing. Waterfall Lifecycle. Iterative Lifecycles. Prototyping. Scheduling and Estimation. Advantages of Accurate Schedules. Difficulties of Accurate Scheduling. The ROPES Macro Cycle. Analysis. Requirements Analysis. Systems Analysis. Object Analysis. Design. Architectural Design. Mechanistic Design. Detailed Design. Translation. Activities. Artifacts. Testing. Activities. SECTION 2: ANALYSIS. 5. Requirements Analysis of Real-Time Systems. Terms and Concepts. Use Cases. Messages and Events. Scenarios, Protocols, and State Machines. Use Cases. Use Case Relations. Use Case Example: Air Traffic Control System. External Events. Context-Level Messages. Specifying External Messages. External Event List. Response Time. Detailing Use Case Behavior. Informal Textual Description. Scenarios. Sequence Diagrams. Statecharts for Defining Use Case Behavior. Identifying Use Cases. Using Use Cases. Heuristics for Good Requirements Analysis Diagrams. Use Case Diagram Heuristics. Use Case Heuristics. Use Case Sequence Diagram Heuristics. 6. Structural Object Analysis. Terms and Concepts. Key Strategies for Object Identification. Underline the Noun. Identify Causal Agents. Identify Coherent Services. Identify Real-World Items. Identify Physical Devices. Identify Essential Abstractions of Domains. Identify Transactions. Identify Persistent Information. Identify Visual Elements. Identify Control Elements. Execute Scenarios on the Object Model. Reification of Objects into Classes. Identify Object Associations. Multiplicity. Associations and Links. Aggregation and Composition. Object Attributes. Generalization Relationships. AATCS Example: Class Diagrams. Heuristics for Good Class Diagrams. Rules for Good Class Diagrams. 7. Object Behavioral Analysis. Terms and Concepts. Simple Behavior. State Behavior. Continuous Behavior. UML Statecharts. Basic State Semantics. Transitions and Events. Actions and Activities. Pseudostates. Orthogonal Regions and Synchronization. Basic Statechart Syntax. Inherited State Models. Ill-formed State Models. Example: AATCS Alarm System. The Role of Scenarios in the Definition of Behavior. Timing Diagrams. Sequence Diagrams. Activity Diagrams. Defining Operations. Types of Operations. Strategies for Defining Operations. Statechart Heuristics. Timing Diagram Heuristics. Activity Diagram Heuristics. SECTION 3: DESIGN. 8. Architectural Design. Terms and Concepts. Tasking Model. Representing Tasks. Defining Task Threads. Assigning Objects to Tasks. Defining Task Rendezvous. Component Model. Deployment Model. Representing Physical Architecture in the UML. Multiprocessor Systems. Safety/Reliability Model. 9. Mechanistic Design. Terms and Concepts. Design Pattern Basics. Mechanistic Design Patterns. Correctness Patterns. Execution Control Patterns. 10. Detailed Design. Introduction to Detailed Design. Terms and Concepts. Data Structure. Primitive Representational Types. Subrange Constraints. Derived Attributes. Data Collection Structure. Associations. The Object Interface. Definition of Operations. Detailed Algorithmic Design. Representing Algorithms in the UML. Algorithmic Example: Run-Time Data Interpolation. Exceptions. Source Language-based Exception Handling. State-based Exception Handling. SECTION 4. ADVANCED REAL-TIME MODELING. 11. Threads and Schedulability. Terms and Concepts. Time-Based Systems. Reactive Systems. Time Concepts. Scheduling Threads. Rate Monotonic Scheduling. Earliest Deadline Scheduling. Least Laxity Dynamic Scheduling. Maximum Urgency First Scheduling. Weighted Shortest Processing Time First (WSPTF) Scheduling. Minimizing Maximum Lateness Scheduling. Thread Synchronization and Resource Sharing. Mutual Exclusion Semaphore. Dekker's Algorithm. Spinlocks. Counting Semaphores. Condition Variables. Barriers. Rendezvous Objects. Schedulability Analysis of Hard Real-Time Systems. Global Analysis. Global Method with Blocking. Computing Blocking. Separate Task Utilization Bounds. Aperiodic Tasks. Schedulability Analysis of Soft Real-Time Systems. Warm and Fuzzy: Timeliness in the Soft Context. Soft Schedulability. 12. Dynamic Modeling. Terms and Concepts. But is it the Right State Machine? Behavioral Patterns. Latch State Pattern. Polling State Pattern. Latched Data Pattern. Device Mode State Pattern. Transaction State Pattern. Component Synchronization State Pattern. Barrier State Pattern. Event Hierarchy State Pattern. Random State Pattern. Null State Pattern. Watchdog State Pattern. Retriggerable Counter State Pattern. Model-Level Debugging and Testing. Animated Debugging. Animated Testing. Sample Debugging Session. 13. Real-Time Frameworks. Terms and Concepts. Real-Time Frameworks. Architectural Support Patterns. Safety and Reliability Patterns. Behavioral Patterns. Framework Design Principles and Metrics. Set of Services. Generalization Hierarchy Structure. Replaceable Components. Portability. Naming and Syntax Conventions. Performance. The Rhapsody Object Execution Framework (OXF). Rhapsody Architecture. Execution Framework. Interobject Association Patterns. Using C++ Standard Template Library. Abstract Operating System. Animation Framework. Sample Application Using the Rhapsody OXF Framework. Appendix A: UML Notation Summary. Appendix B: Introduction to Rhapsody. Appendix C: Introduction to Timewiz. Index. CD-ROM Warranty. 0201498375T04062001

Use Cases: Requirements in Context

Abstract: From the Book: Use Cases: Requirements in Context came about, as most books probably do, as the result of a complaint. We felt that there weren't any good books that addressed use cases for requirements gathering. It seemed that a lot of people agreed that use cases were a perfectly good tool to solve the requirements problem, but no one had put down on paper any detailed process to help people understand how to use them this way. In fact, even as we write today, in late 1999, there is no book of this sort that we know of. Requirements gathering has been a problem on almost every project we've been involved with. The fuzzy nature of requirements makes working with them slippery and unintuitive for most software analysts. Use cases are the first tool we've seen that addresses the specification and communication concerns usually associated with requirements gathering. Although use cases in themselves are quite intuitive, the process around them is often done poorly. The questions that people have—How many iterations do I do? How fine-grained should a use case be?—are not answered or even addressed in most texts. This is probably because they are hard questions and the answers can vary greatly from one situation to another. However, they are important questions, and we decided to describe our own best practices as a first volley in what we hope will become a spirited industry dialog on how to generate requirements that will address user needs. Use Cases: Requirements in Context is a practical book for the everyday practitioner. As consultants in the information technology industry, we employ use cases to specify businesssystems as part of our daily lives. We think we understand the issues facing people when they deliver software using tools such as the Unified Modeling Language and use cases. Our main intent is not to describe use case notation, although we do address that. Instead, we show a requirements process that addresses requirements gathering in a way that produces quality results. While writing, we considered the factors that cause problems in requirements gathering, and we developed a use case method for delivering a requirements-oriented set of deliverables. The methodology breaks down the activity of producing requirements into a series of steps, and it answers the questions that usually come up when people employ use cases. This book relates directly to the real work of delivering a specification, managing that effort with a team, and getting the most bang for your buck. The sample use cases and use case diagrams that appear throughout the book are also presented in Appendixes B and C. These appendixes demonstrate the development of the use cases and other requirements analysis artifacts through each phase of their development. Appendix B documents a business system for real estate, and Appendix C documents a business system for the garment industry. We hope you enjoy this book. It was a labor of love for us. This is a process that works well for us. If it works for you, too, that's great. If it doesn't, perhaps you can adapt some of the tools, ideas, or suggestions to your own way of addressing the requirements problem.

Visual modeling with Rational Rose and UML

Abstract: (Each chapter concludes with a Summary.) Foreword. Preface. 1. Introduction. What Is Visual Modeling? The Triangle for Success. The Role of Notation. History of the UML. The Role of Process. What Is Iterative and Incremental Development? The Rational Objectory Process. The Rational Rose Tool. 2. Beginning a Project. Defining the Right Project. Eastern State University (ESU) Background. Risks for the Course Registration Problem. ESU Course Registration Problem Statement. 3. Creating Use Cases. System Behavior. Actors. Use Cases. Use Case Relationships. Use Case Diagrams. 4. Finding Classes. What Is an Object? State, Behavior, and Identity. What Is a Class? Stereotypes and Classes. Discovering Classes. Documenting Classes. Packages. Objects and Classes in the ESU Course Registration Problem. Class Diagrams. 5. Discovering Object Interaction. Use Case Realization. Documenting Scenarios. Sequence Diagrams. Sequence Diagrams and Boundary Classes. Complexity and Sequence Diagrams. Collaboration Diagrams. Why Are There Two Different Diagrams? Sequence Diagram for the ESU Course Registration System. 6. Specifying Relationships. The Need for Relationships Association Relationships Aggregation Relationships Association or Aggregation? Naming Relationships. Role Names. Multiplicity Indicators. Reflexive Relationships. Finding Relationships. Relationships in the ESU Course Registration Problem. Package Relationships. Package Relationships in the Course Registration Problem. 7. Adding Behavior and Structure. Representing Behavior and Structure. Creating Operations. Documenting Operations. Relationships and Operation Signatures. Creating Attributes. Documenting Attributes. Displaying Attributes and Operations. Association Classes. 8. Discovering Inheritance. Inheritance. Generalization. Specialization. Inheritance Trees. Single Inheritance versus Multiple Inheritance. Inheritance versus Aggregation. 9. Analyzing Object Behavior. Modeling Dynamic Behavior. States. State Transitions. Special States. State Transition Details. State Details. 10. Checking the Model. Why Homogenize? Combining Classes. Splitting Classes. Eliminating Classes. Consistency Checking. Scenario Walk-Through. Event Tracing. Documentation Review. 11. Designing the System Architecture. The Need for Architecture. The Architecture Team. The "4+1" View of Architecture. The Logical View. The Component View. The Process View. The Deployment View. The Use Case View. 12. Building the Iterations. The Iteration Planning Process. Designing the User Interface. Adding Design Classes. The Emergence of Patterns. Designing Relationships. Designing Attributes and Operations. Designing for Inheritance. Coding, Testing, and Documenting the Iteration. Using Reverse Engineering to Set the Stage for the Next Iteration. Appendix A. Appendix B. Glossary. Index. 0201310163T04062001