Introduction to Visual Modeling Using Rational Rose

---

Contents

This chapter is organized as follows:

• Overview
• Visual Modeling
• Modeling with Rational Rose
• Notations
• Features
• Extending Rational Rose

---

Overview

Rational Rose provides support for two essential elements of modern software engineering: component-based development and controlled iterative development. While these concepts are conceptually independent, their usage in combination is both natural and beneficial.

Rational Rose's model-diagram architecture facilitates use of the Unified Modeling Language (UML), Component Object Modeling (COM), Object Modeling Technique (OMT), and Booch `93 method for visual modeling. Using semantic information ensures correctness by construction and maintaining consistency.

---

Visual Modeling

Increasing complexity, resulting from a highly competitive and ever-changing business environment, offers unique challenges to system developers. Models help you organize, visualize, understand, and create complex things.

Visual modeling is the mapping of real world processes of a system to a graphical representation. Models are useful for understanding problems, communicating with everyone involved with the project (customers, domain experts, analysts, designers, etc.), modeling complex systems, preparing documentation, and designing programs and databases. Modeling promotes better understanding of requirements, cleaner designs, and more maintainable systems.

As software systems become more complex, we cannot understand them in their entirety. To effectively build a complex system, the developer begins by looking at the big picture without getting caught up in the details. A model is an ideal way to portray the abstractions of a complex problem by filtering out nonessential details. The developer must abstract different views or blueprints of the system, build models using precise notations, verify that the models satisfy the requirements of the system, and gradually add detail to transform the models into an implementation.

The models of a software system are analogous to the blueprints of a building. An architect could not design a structure in its entirety with one blueprint. Instead a blueprint is drawn up for the electrician, the plumber, the carpenter, and so on. When designing a software system, the software engineer deals with similar complexities. Different models are drawn up to serve as blueprints for marketing, software developers, system developers, quality assurance engineers, etc. The models are designed to meet the needs of a specific audience or task, thereby making them more understandable and manageable.

Visual modeling has one communication standard: the Unified Modeling Language (UML). The UML provides a smooth transition between the business domain and the computer domain. Using the UML, all members of a design team can work with a common vocabulary, minimizing miscommunication and increasing efficiency.

Visual modeling captures business processes by defining the software system requirements from the user's perspective. This streamlines the design and development process. Visual modeling also defines architecture by providing the capability to capture the logical software architecture independent of the software language. This method provides flexibility to your system design since the logical architecture can always be mapped to a different software language. Finally, with visual modeling, you can reuse parts of a system or an application by creating components of your design. These components can then be shared and reused by different members of a team allowing changes to be easily incorporated into already existing development software.

---

Modeling with Rational Rose

Rational Rose is the visual modeling software solution that lets you create, analyze, design, view, modify, and manipulate components. You can graphically depict an overview of the behavior of your system with a use-case diagram. Rational Rose provides the collaboration diagram as an alternative to a use-case diagram. It shows object interactions organized around objects and their links to one another. The statechart diagram provides additional analysis techniques for classes with significant dynamic behavior. A statechart diagram shows the life history of a given class, the events that cause a transition from one state to another, and the actions that result from a state change. Activity diagrams provide a way to model a class operation or the workflow of a business process.

Rational Rose provides the notation needed to specify and document the system architecture. The logical architecture is captured in class diagrams that contain the classes and relationships that represent the key abstractions of the system under development. The component architecture is captured in component diagrams that focus on the actual software module organization within the development environment. The deployment architecture is captured in deployment diagrams that map software to processing nodes--showing the configuration of run-time processing elements and their software processes.

---

Notations

Notation plays an important part in any application development activity--it is the glue that holds the process together. UML provides a very robust notation, which grows from analysis into design. Certain elements of the notation (that is, use cases, classes, associations, aggregations, inheritance) are introduced during analysis. Other elements of the notation (that is, containment indicators and properties) are introduced during design.

Notation has the following roles:

• Communicates decisions that are not obvious or cannot be inferred from the code itself
• Provides semantics that capture important strategic and tactical decisions
• Offers concrete forms and tools that can be manipulated

---

Features

Rational Rose provides the following features to facilitate the analysis, design, and iterative construction of your applications:

• Use-Case Analysis
• Object-Oriented Modeling
• User-Configurable Support for UML, COM, OMT, and Booch `93
• Semantic Checking
• Support for Controlled Iterative Development
• Round-Trip Engineering
• Parallel Multiuser Development Through Repository and Private Support
• Integration with Data Modeling Tools
• Documentation Generation
• Rational Rose Scripting for Integration and Extensibility
• OLE Linking
• OLE Automation
• Multiple Platform Availability

---

Extending Rational Rose

The add-in feature allows you to quickly and accurately customize your Rational Rose environment depending on your development needs. Using the add-in tool, you can install language (for example, Visual Basic, Visual Java) and non-language (for example, Microsoft Project) tools while in Rational Rose.

When an add-in is installed, it is automatically in an activated state. Add-ins can install:

• Menus (.mnu file)
• Help files (.hlp file)
• Contents tab files (.cnt file)
• Properties (.pty file)
• Executables (.exe)
• Script files (.ebs script source file and .ebx compiled script file)
• OLE servers (.dll file)

Additionally, an add-in can define fundamental types, predefined stereotypes, and metafiles. Note that an add-in is not to be considered strictly a one-to-one association with a round-trip engineering (RTE) integration.

Add-In Manager

The Add-In Manager allows you to control the state of the add-in, whether it is activated or deactivated. If the add-in is deactivated, it is still visible through the Add-In Manager. However, the add-in's properties and menus are not available.

Installing an Add-In

Use the following steps to install an add-in on your Windows 95, Windows 98, or Windows NT system:

1 Exit Rational Rose.

2 Insert the CD ROM or the application that you wish to install.

3 Run the setup.exe program.

4 Respond to the dialogs to complete your installation.

5 Restart Rational Rose. Confirm that your add-in is activated using the Add-In Manager menu.