Managing the development of large software projects is a difficult task for which several methodologies were developed. These methodologies address the activities involved in the different phases of software development: requirements analysis, design, coding and testing. Some aspects of these methodologies are closely related to the underlying programming model. For example, the design may involve specifying the data structures and functions needed.
With the advent of Object Oriented (OO) programming, methodologies evolved or were created to better match the OO constructions offered by the underlying programming languages. Such methodologies include Booch, Coad and Yourdon, Rumbaugh, Shlaer and Mellor, and Wirfs-Brock. These methods have a lot in common. The important OO related aspects of the Rumbaugh methods are outlined below.
Three views, or models, are used to describe the software system: the object model, the dynamic model and the functional model. These models are detailed and refined as the project evolves from analysis to system design and to object design.
The object model describes the data structures (classes) and associated operations (methods). For each class, the following information is specified:
Associations between classes are also documented:
Sometimes individual instances of some classes need to be documented and associations and constraints may involve these objects.
The dynamic model is used to describe sequencing and reactions to events and time. Nested state diagrams are used to represent states (values in objects), events (time, input data, object operation being called) and actions (procedures or object operations). This model is convenient to represent interactions between asynchronous sub systems and with users.
The functional model is used to describe non trivial computations. A data flow diagram is used to describe how the computation is decomposed into simpler operations.
Both the dynamic and functional models are used to describe the operations associated with objects. The dynamic model is more appropriate for control operations while the functional model better describes complex computations.
During the analysis phase, an initial draft of the object, dynamic and functional models is built. It must satisfy the requirements and describe in a relatively detailed way what the system should do, albeit not how it will be done.
The system design details the high level system architecture. The system is decomposed into sub systems allocated to computing resources (processors, tasks, devices, networks). Implementation strategies are also determined during this step, for example for data storage (database management system) or user interface (user interface builder and toolkits).
The last phase brings the system up to the actual code generation. This involves creating internal classes and operations as necessary, detailing the operations and attributes for each class, detailing the algorithms used for each operation and packaging the classes into modules. Iterative refinement optimizes the code reuse (inheritance, aggregation, generics) and system performance.
To support the design methodology, tools may be used. These tools store the design data and may perform consistency checks. Sometimes the design data may be used to generate automatically the class declarations. In other systems, some parts of the design data are extracted automatically from the class declarations. In other cases it is the programmer's responsability to insure that the design data and class declarations are coherent. It is also possible to annotate directly the complete design data as structured comments in the class declarations.