This article will focus on the significance of the Use Case Model within software requirements. You will understand the fundamentals of Use Case Models and you should be able to create your own Use Case Model. You will also understand what a use case specification is and will attempt to apply use cases and model the Use Case Models.
The Use Case Model is used to define the core elements and processes that makeup a system. The key elements are termed as “actors” and the processes are called “use cases.” The Use Case Model shows which actors interact with each use case. This definition defines what a Use Case Model is primarily made up of—actors and use cases.
A Use Case Model should capture the functional system components. It embosses the business processes within the system. While you traverse your system, you will learn significant system attributes that you model in the Use Case Model. Because Use Case Models are simple in nature, they are free of technical jargon, Use Case Models are a great way to storyboard flows with users. Use Case Models have another critical role. Use Case Models define the system requirements being modeled and help write the scenarios later used in testing.
UML Use Case Models can be used to describe the functionality of a system in a horizontal way. That is, rather than merely representing the details of individual features of your system, Use Case Models can be used to show all of its available functionality. It is important to note, though, that Use Case Models are fundamentally different from sequence diagrams or flow charts because they do not make any attempt to represent the order or number of times that the systems actions and sub-actions should be executed. There are a number of graphical examples in this FAQ; you might want to look over them to familiarize yourself with the look of them.
Use Case Models have only 4 major elements: The actors that the system you are describing interacts with, the system itself, the use cases, or services, that the system knows how to perform, and the lines that represent relationships between these elements.
You should use Use Case Models to represent the functionality of your system from a top-down perspective (that is, at a glance the system’s functionality is obvious, but all descriptions are at a very high level. Further detail can later be added to the diagram to elucidate interesting points in the system’s behavior.)
Example: A Use Case Model is well suited to the task of describing all of the things that can be done with a database system, by all of the people who might use it (administrators, developers, data entry personnel.)
You should NOT use Use Case Models to represent exception behavior (when errors happen) or to try to illustrate the sequence of steps that must be performed in order to complete a task. Use Sequence diagrams to show these design features. Example: A Use Case Model would be poorly suited to describing the TCP/IP network protocol, because there are many exception cases, branching behaviors, and conditional functionality (what happens when a packet is lost or late, what about when the connection dies?)
The key components of the Use Case Model are the actors themselves, the use cases tied to the actors, the boundaries where the use cases sit in, and the associations between the previous components. By reading the material below Companye Case Models and looking at the sample below, you should be able to get a good grasp to build your own Use Case Model.
When working from an Action/Response table, itentifying the actors is easy: entities whose behavior appears in the “Actor’s Actions” column are the actors, and entities whose behavior appears in the “System’s Response” column are components in the system.
If you are working from an informal narrative, a sequence diagram, or a scenario description, the actors are typically those entities whose behavior cannot control or change (i.e., agents that are not part of the system that you are building or describing.) The most obvious candidates for actors are the humans in the system; except in rare cases when the system you are describing is actually a human process (such as a specific method of dealing with customers that employees should follow) the humans that you must interact with will all be actors. If your system interacts with other systems (databases, servers maintained by other people, legacy systems) you will be best to treat these as actors, also, since it is not their behavior that you are interested in describing.
Example: When adding a new database system to manage a company’s finances, your system will probably have to interface with their existing inventory management software. Since you didn’t write this software, don’t intend to replace it, and only use the services that it provides, it makes sense for that system to be an actor.
The system box only appears on the top-level diagram (remember that a typical UML Use Case description will be composed of many diagrams and sub-diagrams), and should contain use case ovals, one for each top-level service that your system provides to its actors. Any kind of internal behavior that your system may have that is only used by other parts of the system should not appear in the system box. One useful way to think of these top-level services is as follows: if a use case represents a top-level service, then it should make sense for the actors who interact with it to request only that service of your system in a single session (in whatever sense a “session” is intelligible in your system.)
Example: In the diagram below we would like to represent the use cases for a camera. Suppose we choose “Open Shutter”, “Flash”, and “Close Shutter” as the top-level use cases. Certainly these are all behaviors that a camera has, but no photographer would ever pick up their camera, open the shutter, and then put it down, satisfied with their photographic session for the day. The crucial thing to realize is that these behaviors are not done in isolation, but are rather a part of a more high-level use case, “Take Picture”. (Note that it does make sense for a photographer to “Take Picture” just once during a session with their camera.)
The actors in my Use Case Model have interactions. How do I represent them?
If there are interactions between the actors in your system, you cannot represent those interactions on the same diagram as your system. What you can do instead is draw a separate Use Case Model, treating one of the actors itself as a system, and your original system (along with the other actors) as actors on this new diagram.
Example: Suppose you wanted to diagram the interactions between a user, a web browser, and the server it contacts. Since you can only have one system on the diagram, you must choose one of the obvious “systems”, such as the server. You might then be tempted to draw interaction lines between the actors, but this is a problem because it isn’t clear what the interaction means, so it isn’t helpful to show it here. A more useful solution would be to draw two diagrams, showing all of the interactions, as below.
Do Use Case Models show sequences or procedure? Using a UML Use Case Model, you can’t. Use Case Models are meant to be a top-down, horizontal description of functionality, not a blow-by-blow desrciption of behavior. For the most part, it isn’t a good idea to try to represent sequences of actions with Use Case Models. You should use a Sequence Diagram or a traditional flow chart instead. (It is possible to represent simple branching conditions with a Use Case Model, as described below, but you should use this technique sparingly because it can render a diagram unreadable.)
As mentioned above, Use Case Models represent functionality in a top-down way, whereas flow charts represent behavior in a linear, time-based way. Also, the way you develop them is all-together different.
Example: (This text refers to the diagrams below.) When constructing a Use Case Model, the initial step is to identify all of the top-level behavior. Once you have done this (not a very tricky process) you have already described, at least in a high-level way, all of the things your system knows how to do. You can then continue to add detail by decomposing your use cases into more use cases which are used by the top-level use cases. At every stage of development, though, your Use Case Model is a complete description of the system’s functionalty: it may lack detail, but it will not lack feature set elements. And if functionality or behavior is added or deleted over the life of your project, the scope of the change you need to make is proportional to both the scope of the change in the system itself, and the maturity of your model. This is useful because it means that when your model is very young (only high-level diagrams drawn) making sweeping changes to the system does not involve throwing very much work away. A flow chart, however, does not correctly describe the system until you have finished drawing it, and even then small changes in the system will result in significant reworking of your flow charts. In general, Use Case Models support the process of analysis and design much better than flow charts.
The uses arrow (or uses edge as it would be called in traditional graph thoery) is drawn from a use case X to another use case Y to indicate that the process of doing X always involves doing Y at least once (although it may involve doing it many times, “at least once” is the only relationship guaranteed by this symbol.) This symbol can be referred to as an aggregation operator, because it indicates that a given use case is an aggregate (made up of parts) whose components are the use cases that it uses. If a certain use case uses several others, that means that all of the component use cases must be completed in the process of completing the aggregate use case, although there is no specification in Use Case Models of the order in which these are completed. A brief, mnemonic way to think about the uses arrow is that it it can be read X uses Y means that “X has a Y” as part of it’s behavior.
Example: Suppose you wanted to add detail to the diagram shown below, representing an airline reservation system. First, you would create a separate diagram for the top-level services, and then you would add new use cases that make up the top-level ones. There is a uses edge from “Check in Passenger” to “Weigh Luggage” and from “Check in Passenger” to “Assign Seat”; this indicates that in order to Check in a Passenger, Luggage must be Weighed and a Seat must be Assigned. Similarly, the diagram indicates that in order to add a reservation to the system, the available space must be checked and the passenger’s information must be recorded. You could imagine breaking these use cases down further to show more detail.
The extends arrow (or extends edge) is drawn from a use case X to a use case Y to indicate that the process X is a special case behavior of the same type as the more general process Y. You would use this in situations where your system has a number of use cases (processes) that all have some subtasks in common, but each one has something different about it that makes it impossible for you to just lump them all together into the same use case.
Example: Suppose you wanted to add detail to the diagram shown below, representing an airline reservation system. Specifically, what you would like to show is that not all of the seats aboard the airplane are exactly alike (some window and some aisle seats), and sometimes passengers will express a preference for one of these types of seats but not the other. But of course, they cannot just be given their preference right away, because the seat they want might not be available. Therefore, the process of assigning a window seat involves checking for the availability of window seats, whereas the process of assigning an aisle seat involves checking for the availability of aisle seats. But even though these processes are different, they are quite similar in a number of other ways, so it doesn’t make sense to ignore their similarities. Fortunately, UML lets us have both: we write that assigning these two types of seats are different processes, but they are similar in that both processes extend a common, more general process (assigning seats.)
For the generalization concept, a use case describes a variation on another use case, use a generalization link. In the example below, the use case limit exceeded describes a situation in which the usual scenario of online purchase is not performed. Use cases that generalize another use case should only specify an alternative, even exceptional, scenario to the use case being generalized. The overall goal of the use cases should be the same.
For the extends concept, in some instances you want to describe a variation on behaviour in a more controlled form. In such instances you can define extension points in the extended use case. In the example below, search by name is said to extend search at the name extension point. The extends link is more controlled than the generalization link in that functionality can only be added at the extension points.
When starting a Use Case Model (or use case model), it is very important to keep it simple. Often it is easiest to first determine the actors of the system, and then flush out the use cases that they perform. Your Use Case Models can be as simple or complex as you wish, however simpler, less cluttered diagrams are easier to understand, and are often more powerful in capturing the tasks of the system.
Using Gatherspace, you can produce your use case model at a very high level. While it won’t provide some complex concepts like generalizations, it will provide you a good high-level start that you can share with your customers and project team.