Rational Rose 2001 helps customers design and develop software in an Internet-connected, global economy. As the Internet has grown to dominate both business and technology decisions, all organizations face an e-software paradox. Traditionally, development organizations could choose between higher software quality or reduced time-to-market. In the new Internet economy, organizations have no choice: they must deliver higher quality software in less time. Rational Rose helps companies overcome the e-software paradox by unifying the communities that develop software with a common visual language that accelerates the creation of flexible applications with robust, resilient architectures.
The Rational Rose 2001 release notes describe:
For any last-minute information not available when the release notes were published, please check the readme.txt file in the doc folder of your installation directory.
Before installing Rational Rose 2001 and its add-ins, be sure to read the See Hardware/Software Information and sections of this document. These sections contain important information for a smooth and successful installation.
This section provides basic information on the platforms supported and the hardware and software requirements for installing and running Rational Rose 2001 and its add-ins.
Rational Rose 2001 and its add-ins run on any of the following operating system platforms:
The following hardware requirements apply to Rational Rose 2001 and its add-ins:
The goal of all Rose technical documentation is to provide the most appropriate and useable product information possible so that our users can benefit fully from all of the features of Rose and its add-ins. To that end, Rose 2001 and its add-ins provide a complete, integrated online help system, along with a set of supplemental printed manuals.
You may notice that the printed documentation set has changed, beginning with this release. Several printed manuals, whose content was exactly the same as that of the online help, have been eliminated. On the other hand, several new books that provide important background or supplemental information are now available. In future releases, we hope to provide more of these value-add publications, while continuing to update our comprehensive online help systems.
To print the complete online help for Rose 2001 or any of its add-ins, you can easily do so from the Contents tab of the help system:
All of the help topics contained in the selected book (including those that are contained in sub-books of the selected help book) will print in the order in which they appear in the table of contents.
Of course, you can still print single topics whenever you need to do so.
In addition to the Release Notes, the following manuals constitute the printed documentation available for Rose 2001 and its add-ins:
These manuals are also available in portable document format (pdf) on the documentation CD that comes with all editions of Rational Rose. You can also download the pdf files from the Rational website, www.rational.com .
The documentation CD contains a comprehensive online tutorial for Rose, as well as one for the Rose Oracle8 add-in. You can also access Rose tutorials on the web by going to www.rational.com and navigating to the Try It Center for Rose.
The Rose tutorial is distributed as a self-extracting archive file that is meant to be copied onto the hard drive of the machine where Rose is installed. The filename is RoseTutorialFiles.exe . This file is approximately 4MB in size. When extracted, it requires approximately 28MB of free disk space. Refer to the Tutorial Read Me file located on the Rose Start menu for more information about this tutorial.
The Rose tutorial provides an overview of Rational Rose, and then takes you through the application development process from business modeling to application implementation, with detours into data modeling and team development.
The self-extracting file that contains the tutorial does not uninstall when you uninstall rose from your system. You must manually remove the tutorial files when you uninstall Rose.
For best tutorial viewing quality, set your display's Color Palette to True Color or the highest number of colors possible (Click Start > Settings > Control Panel > Display > Settings ).
If you have questions about installing, using, or maintaining this product, contact Rational Technical Support as follows:
This section provides information about pre-installation and licensing issues for Rose 2001.
It also describes any known installation and licensing defects, as well as those fixed in this release.
If you encounter a problem while installing or licensing Rose 2001, please check for information under Known Installation Issues , later in this section. If the problem does not appear in this section, please contact Rational Technical Support.
Follow these guidelines before installing Rose 2001 on your system:
You should always have a back up of all your model files. These can include files that end with .mdl,.cat,.ptl, .red, and .sub files.
The following features and enhancements are new for the Rose 2001 release:
The Rational Rose Extensibility Interface (REI) provides several ways for you to extend and customize Rose's capabilities to meet your specific software development needs. Using REI capabilities, you can:
The following features and enhancements are new for the Rose 2001 release of the Rose Extensibility Interface (REI).
Define or determine if an operation is abstract using the Operation.Abstract property.
The Repository Add-In is no longer a supported feature of Rational Rose; however, the add-in is included with the release to support customers' legacy requirements.
To obtain source code for the Repository Add-In, go to the Download Center on Rational Rose's Product Support page and follow the links to the Repository code.
Rational QualityArchitect is a powerful collection of integrated tools for testing middleware components built with technologies such as Enterprise JavaBeans and COM.
QualityArchitect, in conjunction with Rational Rose, generates test scripts for components and interactions in your Rose model. Once generated, the test scripts can be edited and run right from your development environment or from Rational TestManager.
With QualityArchitect, you can:
Rational QualityArchitect has its own release note. For more information on this product, select the QualityArchitect readme file, which is accessible from the Start Programs menu.
Rose ANSI C++ is the new Rational Rose language add-in in support of the C++ programming language.
Because of its many benefits, users are encouraged to convert their models from Rose C++ to Rose ANSI C++. Rose ANSI C++ is designed to be powerful enough to handle large projects, with particular emphasis on scalability and completeness of language support. The user interface has been completely overhauled to make it easy to understand and use.
A model converter is included as an add-in with this release, and the ANSI C++ online help provides instructions for this easy conversion.
Rose ANSI C++ provides the following features:
The Rose Ada add-in allows you to produce Ada source code from the information contained in a Rose model.
The code generated for each selected model component is a function of that component's specification and code-generation properties, and the model's properties. These properties provide the language-specific information required to map your model onto Ada.
Rose/Ada preserves user-supplied declarations and statements from one iteration to the next. You place such user-supplied code in protected code regions which are preserved whenever code is re-generated.
The default value of the Ada95 project property, GenerateStandardOperations is now set to True.
The UseColonNotation property (default TRUE), is used to control whether colon notation is permitted. Note that if you set the property value to False, you will get errors if you use colon notation.
Using the Rational Rose C++ add-in, you can produce C++ source code from the information contained in a Rational Rose model. The code generated for each selected model component is a function of that component's specification and code generation properties, and the project's properties. These properties provide the language-specific information required mapping your model onto C++, and allow you to control the code generated for each component.
When upgrading from a previous release, it is important to understand the various versioning considerations associated with the upgrade. To help you stay in control when regeneratiang code of a different version, Rose C++ generates a version stamp and includes it in the generated code . Refer to the Rose C++ Code Generator Versioning online help to learn more about this feature.
If you are using an older, version stamp unaware code generator to update version stamped code (C++ code generator versioning) the version stamp comment will end up in the orphaned section at the end of the module. This raises the same issues as described in the C++ annotation downgrade topic. The recommended action is to use the newer code generator. It is likely that other preserved regions will also end up in the orphaned section. If you decide to undo this operation, you will have to manually revive the written backup files.
A minor version downgrade occurs when you update code that had been written with a newer code generator, which supports the same annotation format.
Minor downgrades may introduce problems if your current model/code depends on capabilities that have been introduced in the newer code generator. Note that minor upgrading will remedy those problems. Therefore minor downgrades will not raise problems which may require manual work. However, you should allow the downgrade only if you are sufficiently certain that you are not causing problems.
The capability to honor a minor version attempt can be controlled in the same way as the annotation version downgrade. So even though minor downgrading is far more reasonable, the behavior regarding error/warning messages and default setting is the same. Setting the Boolean project property AllowGenerateOverNewerVersion to True will allow you to perform the downgrade. The code generator will still issue a warning in order to make you aware of the potentially unintended downgrade. The default setting is false which makes the code generator issue an error and skip this module.
The C++ code generator uses annotations (protected regions) in the code in order to support non-destructive code regeneration (code updating). The C++ Analyzer takes advantage of the annotations as well.
As the code generator advances using code generators of different versions, the same code base becomes problematic. This is the case when the annotations format changes. A code generator versioning stamp and a surrounding mechanism has been introduced to address this problem.
A particular code generator will produce a version stamp that characterizes the annotations format used and the version of the code generator relative to this annotation format. They are called annotation version and minor version. The version stamp itself has the form of a protected/preserved region. It is not meant to be modified or deleted by the user in any way because it is used differently than other preserved regions. Text added in the region will not be maintained. In addition, the preserve tag must not be set to false.
A particular code generator version will only write the newest version of annotations. However, it can read and interpret older versions of the prior annotation version. How far the backward compatibility goes depends on the kind of change introduced. The code generator will issue a warning message when an annotation upgrade occurs. Refer to the C++ Annotation Upgrade topic to read more about the implications of upgrading the annotation format. Upgrading to a higher minor version is the recommended path and does not cause any problem because it does not require any transformations. The annotation format has not changed.
Downgrading code, which is updating code produced by a higher version code generator, is a risk. The exact risk depends on the usage of newer code generator features and how models that produce the code are going to be shared. In order to allow the user to decide what downgrading risk to engage, two Boolean project properties AllowGenerateOverNewerAnnotations and AllowGenerateOverNewerVersion have been introduced. The default property sets assumes that no risk should be taken. They are both set to False. If the property does not allow overwriting newer code, the code generation displays an error message and skips the module. Otherwise, it will issue a warning and continue.
There are some additional considerations when using an older code generator that is not aware of version stamps. The first version of the version stamp aware code generator is version 1.1. If it does not find a version stamp, it will assume that the file had been written by an older code generator. The behavior is as if found a stamp denoting version 0.0. The C++ version comment orphaned topic contains more information about the effects when using a version 0.0 code generator on newer version stamped code.
A major annotation upgrade happens when code is updated that had been written with an older code generator that supports an older annotations format.
An annotation upgrade is introduced to put more information in the code in order to find preserved regions properly in complex situations. For example, support for recognizing the preserved regions for property generated operations (such as assignment operators) copy constructor when the class name changes.
Changing the annotation format has disadvantages, which is the reason why they occur only after careful consideration of alternatives. One disadvantage is that upgrading to a new format can create problems if the upgrade occurs at the wrong time. Whether this is true or not depends on the particular format change introduced. In addition, upgrading is in general restricted to a particular number of versions.
A particular code generator will support upgrading from the next lower annotation version under stable conditions. Stable conditions means that the upgrade should occur on code that has been successfully updated using the code generator from which to upgrade. If the current code does not fit the model, upgrading and synchronizing at the same time may fail. The steps to assure stable conditions are:
A major annotation downgrade occurs when you update code that had been written with a newer code generator supporting a newer annotation format. Refer to the C++ annotation upgrade topic for reasons why the annotations format may change. It must be expected that the older code generator may not be able to recognize the code regions with the newer annotation. It is particularly problematic to share code using code generators, which support different annotation versions. The exact risk depends on the usage of newer code generator features and how models and especially the produced code are going to be shared.
Downgrading annotations is neither recommended nor automatically supported. You may have to do manual work.
However, you may have valid reasons to dismiss all these considerations. Setting the Boolean project property AllowGenerateOverNewerAnnotations to True will allow you to perform the downgrade. The code generator will still insist to issue a warning though.
The default setting is false, which makes the code generator to issue an error and to skip this module.
The ClearCase add-in provides a tight integration between Rational Rose and the Rational ClearCase version control system. This add-in is intended as a replacement for the ClearCase capabilities provided through the generic Version Control Add-In. Unlike the Version Control Add-In, the ClearCase Add-In does not use the Microsoft SCC API to communicate with ClearCase. This allows for more ClearCase-specific customization to this add-in.
If you are already familiar with the Version Control Add-In, you will find the transition to the ClearCase add-in simple because the many of the dialogs and menu items are identical.
The new features and enhancements of this version of the Rose ClearCase add-in are:
The Rational Rose Corba add-in allows you to forward engineer Rose model elements into Corba-compliant IDL code and reverse engineer CORBA IDL code into a Rose model.
For this release, in support of the CORBA 2.3 specification, Rose CORBA now implements the use of value types. Value types allow you to pass objects by value rather than by reference, which is particularly useful when an object's primary purpose is to encapsulate data, or when an you want to explicitly make a copy of an object. Two new CORBA stereotypes make use of this enhancement:
These stereotypes are not yet documented in the online help.
In addition, this release of Rose CORBA uses the new modeless R2Editor, which provides a user-friendly environment for code generation and updating.
Rational Rose Data Modeler is a database modeling and design tool using UML (Unified Modeling Language) notation. It allows you to work with UML object models as logical models and data models as physical models, and helps you maintain synchronization between the data model and the database.
Data Modeler supports round-trip engineering between the data model, the object model, and the database or DDL file. You can:
In addition to round-trip engineering, you can build a data model. You can:
The following describes the new Data Modeler add-in features that are available for this release of Rational Rose.
Data Modeler now supports Sybase Adaptive Server 12.x
Data Modeler allows you to create, edit, delete, and use specifications for the following elements:
The Data Modeler compare feature operates using a wizard with an enhanced differences report. The final release of this add-in will also include Synchronization of the database or DDL file and the data model.
This release of Data Modeler enhanced the custom trigger for the Oracle and DB2 models adding:
Data Modeler still provides automatic key migration, but now also allows you to migrate either the primary key constraint or unique constraint of your choice.
Data Modeler uses customized stereotype icons for data model elements.
Data Modeler allows you to view physical order changes on the browser and the Data Model Diagram.
Data Modeler allows the primary key to be transformed between the object model and data model as a candidate key.
This release of Data Modeler enhanced the performance of reverse engineering SQL Server 7.0 databases
Data Modeler Compare and Synchronization feature operates using a wizard that generates a graphical report of the differences between the data model and your DDL script or DBMS database, allowing you to synchronize data model elements with elements in your DDL script or DBMS database. This wizard also allows you to save the report of the differences before you synchronize.
Data Modeler allows you to migrate your schema from one DBMS to another, or from one version of a DBMS to a different version of that same DBMS.
Data Modeler supports SQL Server NT authentication.
Data Modeler supports the reverse engineering of the SQL Server bracket quoted identifier.
The Framework Add-In provides a library of frameworks that can be used as templates when creating new models. The Framework Add-In also provides a wizard that helps you add additional frameworks.
The Rose J add-in supports true round-trip engineering and provides support for large frameworks. This release of the Rose J add-in provides the following new capabilities:
Rational Rose Oracle8 enables you to create object models from Oracle8 relational schemas and extend them to exploit Oracle8's object capabilities.
Rational Rose Oracle8 visualizes existing relational databases and facilitates the discovery and composition of existing business objects. This enables you to preserve your investment in existing relational databases while taking advantage of all the benefits that object modeling and development bring to desktop and server applications.
The Rose Model Integrator Add-In lets you compare model elements from up to seven contributor files, discover their differences, and merge them into the base model. This release of Rose Model Integrator includes a new filtering feature, as well as support for unique identifiers, both of which enhance your ability to merge Rose model diagrams:
This feature allows you to ignore small changes in the position of objects in a Rose diagram when merging models.
You can access this feature from within Rose Model Integrator by selecting Filtering from the Options menu. This brings up the Filter Properties dialog box, which lists several Rose model properties and filter values for each one.
This feature adds unique identifiers to all Rose diagram elements. These unique identifiers enable Model Integrator to better track changes in model diagrams. You should note that these identifiers will also increase the size of your model files, both in memory and on disk, so enabling this feature is optional with this release. If you have problems merging models with drawings, you may want to try this feature; otherwise, you may not want to enable it.
To enable support for unique identifiers in Rose model diagram elements, you must modify the rose.ini file that is used when your copy of Rose is started.
Enabling unique identifiers support can improve the performance of Model Integrator when merging models with diagrams. For complete details on both of these new features, see the Rose Model Integrator online help.
The Rose Type Library Importer add-in allows you to import a type library of a COM component into the model by dragging the COM component from Windows Explorer and dropping it in Rational Rose.
You can control several aspects of how type libraries are imported into the model. For example, you can control:
The Version Control Add-In, formerly known as the Source Code Control Add-In, provides integration between Rational Rose and any SCC-compliant version control system. It makes the most frequently used version control commands accessible directly from the Tools menu and from shortcut menus in Rose.
The specific Visual SourceSafe (VSS) integration available in Rose 98i was incorporated into the Version Control Add-In in the Rose 2000 release. This Add-In now handles a super set of the VSS specific features. To upgrade a model that has been put under version control through the VSS Add-In, use the following steps:
Because the model is already under version control, the Version Control Add-In only updates the controlled units with additional version control information. From now on you can use the Version Control commands to check out and check in the units.
The Rose Visual Basic add-in enables Rose to model, generate, and reverse engineer code for applications written in Microsoft Visual Basic. The Rose Visual Basic Language Support tools in Rose are tightly integrated with the Microsoft Visual Basic environment, allowing you to seamlessly progress through the round-trip engineering process.
The Visual Basic Add-In release note describes new features and enhancements, known problems and limitations, and fixed defects since the last release.
The Visual Basic Add-In tools are:
This release of Rose Visual Basic includes a WinDNA code template enhancement. The fetch methods provided by the ADB.Fetcher code template for Visual Basic classes can now connect to a database using either stored procedures or SQL statements. The previous release supported only SQL statements.
The Rational Rose Visual C++ Add-In provides the interface between the Rational Rose modeling environment and Microsoft Visual C++. The main features of Rational Rose Visual C++ include:
Rational Rose Visual C++ now supports the following C++ language constructs:
Refer to the online help for details on how these constructs are mapped to UML.
The Model Assistant now supports enum classes, typedef classes, and nested classes. When you open the Model Assistant on a class, you can quickly navigate to any of its base classes or any associated classes by right-clicking the relation icon and selecting Browse .
Rose Visual C++ uses the UML role "specifier" to contain the implementation code for an association role. For example, if there was an association from class Client to class Server , and the desired implementation for that role was a CObList collection class, then the association role name would be
where the expression after the colon is the UML role specifier.
Rational Rose will now let you control the diagram visibility of the role specifier. You can set the default behavior for the whole diagram from the Diagram tab of the Tools/Options dialog. You can also right-click on any individual role to turn the role specifier visibility on or off for that role.
When you create a new class in the model, you can now specify the name of the file in which the header code should be generated. You can also specify the name of a file to receive any function body code that is generated. For details, check the online help index for the following topics:
In previous releases, the Model Update Tool always placed classes that were new to the model in the Logical View\Reverse Engineered\<ComponentName> package. You can now specify the default package using the Model Update tab on the Tools/Visual C++/Properties dialog. The defaults are:
Users of controlled units in team development take advantage of the Virtual Path Map feature in Rose. This feature allows controlled units in a model to be moved between different folder structures on different computers.
Rose/Visual C++ saves the folder location of Visual C++ project files in the model. By default, it does not save the path as a virtual path.
Follow these steps to change this default behavior:
Refer to Virtual Path Maps (Overview) in the online help for more information.
This release of the Rose Visual C++ Add-In is backward compatible with previous versions of the add-in.
The support for MIDL in this version of Rose is deeper than in Rose 2000. When you use Code Update Tool or Model Update tool on a model created by Rose 2000, this version of Rose will automatically add new components stereotyped as <<MIDL>> for existing components that represent MIDL projects. Model classes that are stereotyped <<coclass>> or <<interface>> will be automatically assigned to the <<MIDL>> components.
It is recommended that you use the Model Update tool on your Rose 2000 models before attempting to generate code using this version of Rose.
The model formats used by the Visual C++ and Classic C++ Add-Ins are not interchangeable. If you want to use the Rose Visual C++ on models created for use with the Rose Classic C++, you must convert the models using the Model Converter.
On the Tools menu, click Visual C++ and then click Model Converter .
The Rational Rose Web Modeler provides visualization, modeling, and tools for developing web applications.
To support visualizing and modeling N-tier web applications, Rose Web Modeler assigns a set of stereotypes and tagged values to your web artifacts. Unified Modeling Language (UML) extensibility features enable modeling the artifacts required to build a web application. Stereotypes and tagged values represent an extension of UML.
Rose Web Modeler creates a model of your multiple tier web application, using specific web artifacts. It supports the Microsoft Windows DNA 2000 (WinDNA), and IBM E-Business Architecture Framework (EBAF) technologies used to build and deploy e-commerce systems.
To visualize and model N-tier web applications, you select the web artifacts from a directory. Rose parses the web artifacts and creates views to show the static structure using the stereotypes and tagged values implement for visualizing and modeling N-tier web applications. You can use Rose Web Modeler to parse HTML files and forms (.htm and .html files) and active server pages (.asp and .asa files).
Rose Web Modeler creates the following diagrams from your N-tier web application:
Rose Web Publisher allows you to publish Rational Rose models in HTML format. The Web Publisher Add-In exports your Rose model as HTML (including diagrams) so you can view them using a standard browser such as Microsoft Internet Explorer or Netscape Communicator. The Web Publisher also produces meta tags for use by search engines.
The Rational Rose XML DTD Add-in provides visualization, modeling, and code generation to create XML document type definitions (DTD) for use in your application. You can reverse engineer an existing XML DTD to visualize a DTD's structure using a Rose class diagram. After modeling an XML DTD, you can use the Syntax Checker to validate your XML DTD. From the valid XML DTD model, you generate code to create a new XML DTD.
In addition to reverse engineering an existing XML DTD, you can model a DTD using Rose class stereotypes for XML elements, element attributes, entities, and notations. By modeling an XML DTD, you can visualize the structure of the document to see which element definitions to change or remove. You can also share your XML DTD model with members of your development team to verify that you have captured the XML document requirements.
An XML DTD syntax checker finds errors in the XML DTD model, allowing you to make corrections before the DTD before is implemented. Use the Generate Code feature to produce an XML DTD that you can test or implement in your environment.
To support mapping XML to UML, Rational Rose extends UML with stereotypes for XML elements, element attribute lists, entities, and notations. Stereotypes also represent XML operator symbols, sequence lists, choice lists, and element and element attribute multiplicity.
Rational, the Rational logo, Rational Rose, ClearCase, and Rational Unified Process are trademarks or registered trademarks of Rational Software Corporation in the United States and in other countries.
Visual C++, Visual Basic, Windows NT, Developer Studio, and Microsoft are trademarks or registered trademarks of the Microsoft Corporation. BasicScript is a trademark of Summit Software, Inc. All other names are used for identification purposes only and are trademarks or registered trademarks of their respective companies.