Object Modeling Technique - Summary Note

Katsuya Amako (KEK)
Version : June 28, 1995

This is a summary note of the Object Modeling Technique, which is described in the book shown below. Please send your comments on this summary to Katsuya Amako.

J. Rumbaugh, M. Blaha, W. Premerlani, F. Eddy, W. Lornsen
Object-Oriented Modeling and Design
Prentice-Hall International Editions, ISBN 0-13-630054-5

Methodology Summary of OMT

The methodology is divided into four phases:

1. Object Analysis Phase
2. System Design Phase
3. Object Design Phase
4. Implementation Phase

The following are what should be done in each phase.

1. Object Analysis

1. Write a problem statement.

2. Build an object model:

        Object Model  = object model diagram
                        + data dictionary
       

   A description of the structure of the objects in a system including their identity, relationships to other attribute, and operations.

3. Develop a dynamic model:

        Dynamic Model = state diagrams
                        + global event flow diagram
       

   A description of aspects of a system concerned with control, including time, sequencing of operations, and interaction of objects.

4. Construct a functional model:

        Functional Model = data flow diagrams
                           + constraints.
       

   A description of aspects of a system that transform values using functions, mappings, constraints, and functional dependencies.

5. Verify, iterate, and refine the three models:

        Analysis Document = Problem Statement
                            + Object Model
                            + Dynamic Model
                            + Functional Model
       

2. System Design

The first stage of design, during which high-level decisions are made about the overall structure of the system, its architecture, etc.

       System Design Document
               = structure of basic architecture for the
                 system as well as high level strategy
                 decisions.

3. Object Design

In this stage, we shift away from the real-world orientation of the analysis model towards the computer orientation required for a parctical implementation.

       Design Document = Detailed Object Model
                         + Detailed Dynamic Model
                         + Detailed Functional model

4. Implementation Phase

In this stage, the design established in the OOA/OOD is realized in an executable form.

Methodology - Summary Figure

The above procedure is summary as follow:

Practical Approach in Each Phase

Quoted from the Rumbaugh's text, page 261.

Analysis Phase

1. Write or obtain an initial description of the problem statement.
2. Build an Object Model:
   • Identify object classes.
   • Begin a data dictionary containing descrptions of classes, attributes, and association.
   • Add associations between classes.
   • Add attributes for objects and links.
   • Organize and simpify object classes using inheritance.
   • Test access paths using scenarios and iterate the above steps as necessary.
   • Group classes into modules, based on close coupling and related function.
3. Develop a Dynamic Model:
   • Prepare scenarios of typical interactions sequeces.
   • Identify events between objects and prepare an event trace for each scenario.
   • Prepare an event flow diagram for the system.
   • Develop a state diagram for each class that has important dynamic behavior.
   • Check for consistency and completeness of events shared among the state diagrams.
4. Construct a Functional Model:
   • Identify input and output values.
   • Use data flow diagrams as needed to show functional dependencies.
   • Describe what each function does.
   • Identify constraints.
   • Specify optimization criteria.
5. Verfy, iterate, and refine the three models:
   • Add key operations that were discovered during preparation of the functional model to the object model. Do not show all operations during analysis as this would clutter the object model; just show the most important operations.
   • Verify that the classes, associations, attributes, and operation are consistent and complete at the chosen level of abstraction. Compare the three models with the problem statement and relevant domain knowledge, and test the models using scenarios.
   • Develop more detaild scenarios (including error conditions) as variations on the basic scenarios. Use these "what-if" scenarios to further verify the three models.
   • Iterate the above steps as needed to complete the analysis.

System Design Phase

1. Organize the system into subsystem.
2. Identify concurrency inherent in the problem.
3. Allocate subsytems to processors and tasks.
4. Choose the basic strategy for implementing data stores in terms of data structures, files, and databases.
5. Identify global resources and determine mechanisms for controlling access to them.
6. Choose an approach to implementing software control:
   • Use the location within the program to hold state, or
   • Directly implement a state machine, or
   • Use concurrent tasks.
7. Consider boundary condistions.
8. Establish trade-off priorities.

Object Design Phase

1. Obtain operations for the object model from the other models:
   • Find an operation for each process in the functional model.
   • Define an operation for each event in the dynamic model, depending on the implementation of control.
2. Design algorithms to implement operations:
   • Choose algorithms that minimize the cost of implementing operations.
   • Select data structures appropriate to the algorithms.
   • Define new internal classes and operations as necessary.
   • Assign responsiblity for operations that are not clearly associated with a single class.
3. Optimize aceess paths to data:
   • Add redundant associations to minimize access cost and maximize convenience.
   • Rearrange the computation for greater efficiency.
   • Save derived values to avoid recomputation of complicated expressions.
4. Implement software control by fleshing out the approach chosen during sytem design.
5. Adjust class structure to increase inheritance:
   • Rearrange and adjust classes and operations to increase inheritance.
   • Abstract common behavior out of groups of classes.
   • Use delegation to share behavior where inheritance is semantically invalid.
6. Design implementation of associations:
   • Analize the traversal of associations.
   • Implement each association as a distinct object or by adding object-values attributes to one or both classes in the association.
7. Determine the exact representation of object attributes.
8. Package classes and associations into modules.

Object Model Notation - Summary Figure