Tool Mentor: Setting Up Rational Rose for a Project
Purpose
This tool mentor describes how to set up Rational Rose for a project.
This section provides links to additional information related to this tool mentor.
Overview
Setting up Rose for a project means laying the foundation that will enable many team members to work on the same model at the same time. Developing complex systems requires that groups of analysts, architects, and developers be able to see and access the "big picture" at the same time as they are working on their own portion of that picture-simultaneously. Successfully managing an environment where multiple team members have different kinds of access to the same model requires:
- Formulating a working strategy for managing team activity.
- Having the tools that can support that strategy.
Ideally, Rose users work within their own private workspace where they are protected from changes that may be untested or not yet approved.
The following are the basic steps for laying this foundation:
- Define Rational Rose defaults
- Partition the model into controlled units
- Define path maps
- Integrate with a configuration management system
For detailed information about using Rose in a team, see:
-
Team
Development topic in the Rational Rose
online help
Rational
Rose Guide to Team Development manual
1. Formulate
working strategies 
When developing a strategy for working in teams, there are two facets to consider:
- developing a strategy that supports current development
- developing a strategy for maintaining and retrieving the reusable modeling artifacts that result
When developing current projects, the tools a team uses must be able to:
- provide all team members with simultaneous access to the entire model
- control which team members can update different model elements
- introduce change in a controlled manner
- maintain multiple versions of a model
When you develop a system, you are developing valuable project artifacts that can be reused. Artifacts are typically maintained in some type of repository. To support reuse:
- Model artifacts should be architecturally significant units, such as patterns, frameworks, and components (not usually individual classes).
- All team members, no matter where they are located, should have access to reusable artifacts.
- It should be easy to catalog, find, and then apply these artifacts in a model.
A reuse repository can differ from your project's configuration management (CM) system as long as it supports versioning. The repository should also support cataloging artifacts at an appropriate level of granularity; for example, at the component level.
2. Define Rational Rose
defaults
Rose enables you to set model-wide operating defaults, called properties and options, that essentially establish the "rules" that users follow when working with the model. The settings you create are stored in the rose.ini file, which should be put under configuration control if you are using a CM system. You access the model properties and options from the Tools > Options menu.
3. Partition
the model into controlled units
Rose supports dividing a model into manageable pieces by letting you partition a model into separate files called controlled units. When using controlled units, each team or each team member is responsible for maintaining or updating a specific unit. The lowest level of granularity for a controlled unit is a package, since packages are considered the smallest architecturally significant elements in a model (classes are not). Controlled units are the basis building blocks that you put under version control.
You can create a hierarchy of controlled units where top level controlled units can consist of references to other controlled units. For example, you could make all packages controlled units with top-level packages that are pointers to nested packages. When you do this, you enable two developers to check out packages that belong to the same higher level package. How you partition a model and the type of hierarchy you implement will depend on how team members will operate, both physically (who works on which packages) as well as logically (how best to partition the model and preserve its design).
You can create controlled units for packages, deployment diagrams, and model properties. When you create controlled units, you name the new file but you use one of these four extensions for the particular type of controlled unit you're creating:
- logical packages and use-case packages are stored in .cat files
- component packages are stored in .sub files
- deployment packages are stored in .prc files
- model properties are stored in a .prp file
You can have an unlimited number of .cat and .sub files, but since a Rose model supports one deployment diagram, there is only one .prc file. Similarly, there is a single set of model properties and only one .prp file.
4. Define path
maps
Virtual path maps enable Rose to use relative file paths instead of physical file paths when referencing controlled units. This feature enables you to move a model between different systems or directories and to update a model from different workspaces. When you save a model or you create a controlled unit, you save it to a physical location. However, you model file and any parent-controlled units rely on that file path to locate the controlled units that belong to it. By creating and using virtual path maps, you enable Rose to substitute the physical file path with a relative file path, freeing your model from its ties to a physical location.
A leading ampersand (&) in a virtual path map indicates the path is relative to the model file or the enclosing (parent) controlled unit. A common way to implement path maps is to have all team members define &CURDIR=&. This enables you to save a model and controlled units relative to the surrounding context, letting different users open the model and load the unit in different workspaces.
5. Integrate with a
configuration management system
Implementing a configuration management (CM) system is essential for complex projects. A CM system can effectively support team development as long as it:
- protects developers from unapproved model changes
- supports comparing and merging all changes made by multiple contributors
- supports distributed (geographically dispersed) development
Consider using the same CM tool to maintain the models that you use for your other project artifacts, such as source code and dlls.
Since managing parallel development is so crucial, Rose provides integrations with Rational ClearCase and with SCC-compliant version control systems, such as Microsoft Visual Source Safe. By integrating CM systems, Rose makes the most frequently used version control commands directly accessible from Rose menus, including the typical check in and check out functions that are used every day.
