Rational Rose

Introduction
• Rational Rose is a powerful visual modeling tool to aid in
the analysis and design of object−oriented software
systems. It is used to model your system before you write
any code.
• Rational Rose supports business modeling, helping you to
understand the business around the system.
• It helps with systems analysis by enabling you to design
use cases and Use Case diagrams to show the system
functionality.
• It will let you design Interaction diagrams to show how the
objects work together to provide the needed functionality.
• Class diagrams can be created to show the classes in a
system and how they relate to each other.
• Component diagrams can be developed to illustrate how
the classes map to implementation components.
• Finally, a Deployment diagram can be produced to show
the network design for the system.
 Introduction
• A Rose model is a picture of a system from various
perspectives. It includes all of the UML diagrams, actors,
use cases, objects, classes, components, and deployment
nodes in a system.
• It describes in great detail what the system will include
and how it will work, so developers can use the model as a
blueprint for the system being built.
• Rational Rose will help developers by generating skeletal
code. It can do this for a number of different languages
available on the market, including C++, Ada, CORBA, Java,
COM objects, Visual Basic, and XML.
• Further, Rose can reverse engineer code and create a
model based on an existing system. Having a model in
Rose for an existing application is very beneficial. When a
change occurs to the model, Rose can modify the code to
incorporate the change. Similarly, when a change occurs in
the code, you can incorporate that change into the model
automatically. These features help you keep the model and
the code synchronized, reducing the risk of having an
outdated model.
 Introduction
• Rose can also be extended using RoseScript, a
programming language packaged with Rose.
Using this programming language, you can write
code to automatically make changes to your
model, create a report, or perform other tasks
with your Rose model.
• There are three different versions of Rose
currently available:
– Rose Modeler, which allows you to create a model for
your system, but will not support code generation or
reverse engineering.
– Rose Professional, which allows you to generate code in
one language.
– Rose Enterprise, which allows you to generate code for
C++, Java, Ada, CORBA, Visual Basic, COM, Oracle8,
and XML. A model can have components that are
generated in different languages.
 Parts of screen
• The five primary pieces of the Rose interface are
the browser, the documentation window, the
toolbars, the diagram window, and the log.
– Browser Used to quickly navigate through the model
– Documentation window Used to view or update
documentation of model elements
– Toolbars Used for quick access to commonly used
commands
– Diagram window Used to display and edit one or more
UML diagrams
– Log Used to view errors and report the results of
various commands
 Browser
• The browser is a hierarchical structure you can use to
easily navigate through your Rose model. Anything you add
to the model—actors, use cases, classes, components, and
so on—will display in the browser.
• Using the browser, you can
– Add model elements (use cases, actors, classes, components,
diagrams, etc.)
– View existing model elements
– View existing relationships between model elements
– Move model elements
– Rename model elements
– Add a model element to a diagram
– Attach a file or URL to an element
– Group elements into packages
– Access the detailed specifications of an element
– Open a diagram
 Browser
• There are four views in the browser: the Use Case view, the Logical view, the Component
view, and the Deployment view.

View Contents
Use case view Business actors
Business workers
Business use cases
Business Use Case diagrams
Business Use Case realizations
Actors
Use cases
Associations
Use case documentation
Use Case diagrams
Activity diagrams
Sequence diagrams
Collaboration diagrams
Packages
 Browser
View Contents
Logical View Classes
Class diagrams
Associations
Interfaces
Sequence diagrams
Collaboration diagrams
Statechart diagrams
Packages
 Browser
View Contents

Component view Components

Interfaces
Component diagrams
Packages
 Browser
View Contents

Deployment view Processes

Processors
Connectors
Devices
Deployment diagram
 Use case view
• The Use Case view includes all of the
actors, use cases, and Use Case
diagrams in the system. It may also
include some Sequence and
Collaboration diagrams
• It focuses on a high−level picture of
what the system will do, without
worrying about the details of how the
system will do it.
 Logical view
• focuses on how the system will implement the behavior in the use
cases. It provides a detailed picture of the pieces of the system,
and describes how the pieces interrelate.
• The Logical view includes, among other things, the specific classes
that will be needed, the Class diagrams, and the Statechart
diagrams.
• With these detailed elements, developers can construct a detailed
design for the system.
• Frequently, teams take a two−pass approach to the Logical view.
In the first approach, they identify analysis classes. Analysis
classes are language−independent classes.
• By focusing first on analysis classes, the team can begin to see
the structure of the system without getting bogged down in the
implementation−specific details.
• Once the analysis classes have been identified, the team can
change each one to a design class. A design class is a class that
has language−specific details.
Logical view
 Component view
• The Component view contains
information about the code libraries,
executable files, run−time libraries,
and other components in your
model. A component is a physical
module of code.
• In Rose, components and
Component diagrams are displayed
in the Component view
 Deployment view
• The final view in Rose is the
Deployment view. The Deployment
view is concerned with the physical
deployment of the system, which
may differ from the logical
architecture of the system.
 Working with Rose
• Creating Models:
– Select File -> New from the menu, or press the
New button on the Standard toolbar.
– If the Framework Wizard is installed, then the
list of available frameworks will be displayed. If
you select a framework, Rose will
automatically load the default packages,
classes, and components that come with that
framework. For example, loading the J2EE
framework provides default applet, beans, and
other classes
 Working with Rose
• Creating Models:
– Save model: File -> Save
– Export model: file -> export
– Import model: file -> import
• Using the Model Integrator
– The Model Integrator in Rose is a way to
compare and merge up to seven Rose models.
This feature is especially useful in situations
with multiple designers.
– Each can work individually, and then all models
can be integrated into one.
 Working with Rose
• Adding & deleting diagrams:
– The Use Case view typically includes Use Case diagrams,
Activity diagrams, Sequence diagrams, and
Collaboration diagrams. When you create a new Rose
model, one Use Case diagram called "Main" is
automatically created in the Use Case view. This
diagram cannot be removed.
– The Logical view typically contains Sequence diagrams,
Collaboration diagrams, Class diagrams, and Statechart
diagrams. In a new Rose model, one Class diagram
called "Main" is automatically created for you in the
Logical view.
– The Component view contains one or more Component
diagrams, while the Deployment view contains a
Deployment diagram. There is only one Deployment
diagram per system.
 Working with Rose
• Adding & deleting diagrams:
– To add a new diagram:
• Right−click a package in the browser. The new
diagram will be added underneath the package you
have right−clicked.
• Select New -> <diagram type>.
• Type the name of the new diagram.
• Double−click the new diagram to open it.
• To delete a diagram, right−click it in the browser and
select Delete. Note that although the diagram is
• deleted, the model elements, such as classes or use
cases that were on the diagram, are not deleted.