Putting UML to Work

UML provides a useful toolset for systems analysis and design. As with any product created with the help of tools, the value of UML deliverables in a project depends on the expertise with which the systems analyst wields the tools. The analyst will initially use the UML toolset to break down the system requirements into a use case model and an object model. The use case model describes the use cases and actors. The object model describes the objects and object associations, and the responsibilities, collaborators, and attributes of the objects.

1. Define the use case model.
   1. Find the actors in the problem domain by reviewing the system requirements and interviewing some business experts.
   2. Identify the major events initiated by the actors, and develop a set of primary use cases at a very high level that describe the events from the perspective of each actor.
   3. Develop the use case diagrams to provide understanding of how the actors relate to the use cases that will define the system.
   4. Refine the primary use cases to develop a detailed description of system functionality for each primary use case. Provide additional details by developing the use case scenarios that document the alternate flows of the primary use cases.
   5. Review the use case scenarios with the business area experts to verify processes and interactions. Make modifications as necessary until the business area experts agree that the use case scenarios are complete and accurate.
2. Continue UML diagramming to model the system during the systems analysis phase.
   1. Derive activity diagrams from use case diagrams.
   2. Develop sequence and communication diagrams from use case scenarios.
   3. Review the sequence diagrams with the business area experts to verify processes and interactions. Make modifications as necessary until the business area experts agree that the sequence diagrams are complete and accurate. This additional review of the graphical sequence diagrams often provides the business area experts an opportunity to rethink and refine processes in more atomic detail than the review of the use case scenarios.
3. Develop the class diagrams.
   1. Look for nouns in use cases and list them. They are potential objects. Once you identify the objects, look for similarities and differences in the objects due to the objects’ states or behavior, and then create classes.
   2. Define the major relationships between the classes. Look for “has a” and “is a” relationships between classes.
   3. Examine use case and sequence diagrams in order to determine classes.
   4. Beginning with the use cases that are the most important to the system design, create class diagrams that show the classes and relationships that exist in the use cases. One class diagram may represent the classes and relationships described in several related use cases.
4. Draw statechart diagrams.
   1. Develop statechart diagrams for certain class diagrams to provide further analysis of the system at this point. Use statechart diagrams to aid in understanding complex processes that cannot be fully derived by the sequence diagrams.
   2. Determine methods by examining statechart diagrams. Derive state (data) class attributes from use cases, business area experts, and class methods. Indicate whether the methods and attributes of the class are public (accessible externally) or private (internal to the class). The statechart diagrams are extremely useful in modifying class diagrams.
5. Begin systems design by refining UML diagrams and using them to derive classes and their attributes and methods.
   1. Review all existing UML diagrams for the system. Write class specifications for each class that include the class attributes, methods, and their descriptions. Review sequence diagrams to identify other class methods.
   2. Develop methods specifications that detail the input and output requirements for the method, along with a detailed description of the internal processing of the method.
   3. Create another set of sequence diagrams (if necessary) to reflect the actual class methods and interactions with each other and the system interfaces.
   4. Create class diagrams using the specialized class symbols for boundary or interface class, entity class, and control class.
   5. Analyze the class diagrams to derive the system components; that is, functionally and logically related classes that will be compiled and deployed together as a .DLL, a .COM object, a Java Bean, a package, and so forth.
   6. Develop deployment diagrams to indicate how your system components will be deployed in the production environment.
6. Document your system design in detail. This step is critical. The more complete the information you provide the development team through documentation and UML diagrams, the faster the development and the more solid the final production system.