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:
Introduce a development team to use cases and implement a use case approach
Identify the key elements of a use case model, including actors; and the components of a use case, including basic flow, preconditions, post-conditions, sub-flows, and alternate flows
Master the objectives and challenges of creating detailed descriptions of use cases
Improve their descriptions' readability and consistency
Prevent and remedy common problems arising from the misuse of include, extend, and generalization use case relationships
Organize and conduct a review of a use case model to realize the best possible approach
This 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.
Review By: Howard S. Epstein 06/15/2010One of the most important elements of the software development cycle is the requirements gathering and requirements documentation process. Unfortunately, while well-developed requirements are essential to just about any project's success, creating and documenting them in an efficient and effective way is often very difficult to accomplish.
In the mid-1980s, Ivar Jacobson and his team began developing a new way to model the requirements of a system. An overview of this new paradigm, known as use case modeling, is the basis of this new book.
The book is divided into two parts:
Part I introduces the reader to the concepts of use case modeling. In chapter 1, the authors describe what actors are and how critical it is to define them. The authors outline which situations are best for the creation of use cases, and which situations are best left to be documented outside the use case paradigm. Also, the building blocks of a complete use case are described in detail in chapter 2 of this introductory section.
Chapter 3 emphasizes the importance of putting together a system vision—a document that identifies the various stakeholders and their roles, describes the system features, and provides a general summary of the overall value of the system. Chapter 4 is a discussion regarding how to determine system actors as well as how to go about defining their roles. The next and final chapter in this section discusses the fundamentals of putting together a productive use-case modeling workshop—a forum for participants to get together to understand the overall problem the system is intended to solve, to identify the system actors, to determine the use cases, and to document supporting components such as glossary terminology, project issues, risks, and assumptions.
Part II focuses on the mechanics of the use cases themselves, specifically the detailed descriptions that make up the meat of a use case. The first chapter in this section, chapter 6, briefly discusses the various stages that a use case goes through from discovery to a completed description. The succeeding chapter introduces the concept of preconditions and postconditions, the state of a system before a use case is triggered and the state after the use case has ended, respectively. In this chapter, the authors also briefly describe the concept of alternative flows and how they impact the creation of a use case.
Chapters 8 and 9 get to the core of the matter—writing use case descriptions. A number of style tips and guidelines are provided to help the use case writer compile the most effective use cases possible. Chapter 10—appropriately titled "Here There Be Dragons"—touches on some of the more complex use case concepts such as includes, extends, and generalizations, and how to use them appropriately. The authors discuss the most common foibles that use case writers encounter when using these tools.
The penultimate chapter in this section is a discussion of how to get a group of participants together to perform informal and formal use case reviews, and how to make the time spent on these reviews a good investment for those involved. Finally, the last chapter wraps up the discussion by outlining how the various stakeholders benefit from the use-case development process. The authors talk briefly about the Rational Unified Process and how use cases are employed during each stage of this system development methodology.
The appendix includes examples of fully laid out use cases as well as a handy glossary for the reader's reference.
This book serves as a gentle introduction to readers who are generally unfamiliar with the concepts of use case modeling. Secondarily, it can serve as a useful reference to those who have worked with use cases in the past, but need specific information such as how to write an excellent vision document or how to conduct an effective workshop. In general; however, this book targets the beginner, the reader who would like to learn how use cases can be an excellent way to compile system requirements.
Specifically, here is my take on the strengths and weaknesses of this text:
1. For a reader new to the concept of use cases (such as myself), this is an excellent introduction. It moves at a nice, slow pace, dipping the reader's toe into the pool instead of dunking him in like most technically oriented texts tend to do. The book uses a building block approach, introducing new concepts in succeeding chapters that build on what the reader has already learned—a big plus that makes the book a good read from cover to cover.
2. The book is highly readable. The authors do a terrific job outlining simple, but not altogether too simple, examples that highlight the concepts being presented. The book is not dry, but pleasantly conversational.
3. The authors do a fine job pointing out reasons why use case writers often fail to put together an excellent set of use cases. For example, they caution the reader to make sure that the developed use cases are stand-alone descriptions of how the system will add value to a particular actor, and not merely system functions. Understanding these "gotchas" is important in order for the use case writers to compile the most valuable use cases possible.
1. For a reader who is past the beginner's stage, this could be a frustrating text. The authors do not discuss how to actually start creating use case descriptions, the core of a use case, until page 206 (of a 347-page book). If you are looking for a book that gives you a lot of information about the detailed mechanics of use case modeling, I would look elsewhere. This book really is for beginners who have not spent much time working with use cases.
2. The authors probably spend more time telling the reader what NOT to do when creating a use case than actually what to do. They spend a lot of pages discussing a whole host of pitfalls that have caused problems with use cases in the past. Cautionary tales are good, and it is important to understand where use case developers have gone wrong, but there is a bit much of it here.
To sum up, this is a great book for someone who wants to learn about use cases as a possible alternative to other methods of documenting system requirements. I would recommend it to those looking for a good description of what use cases are, what they can and cannot provide, and how to get started developing and using them.