|
Software tools that attempt to model and describe application systems have been around for quite some time. The most visible vendors in the early days of client/server were part of IBM's AD/Cycle architecture, which fell by the wayside after a brief run. The leading company at the time was KnowledgeWare, which produced the IEW and ADW CASE tools. Corporations flocked to get their hands on KnowledgeWare's products so they could model their upcoming applications with the "upper" CASE tools that would then feed the "lower" CASE tools that generated the specific application code. The result was supposed to be a complete system and code that you could reuse for other applications. Problems arose, however, when corporations tried this on an enterprise level, and issues such as model change control, business requirement shifts, and clunky code generation reared their ugly heads.
The new buzzword for modular-based reusable code is "component." While the terminology may be new, developers today are trying (just like their predecessors) to package and reuse the code that finds its way into enterprisewide applications. To be sure, there are vendors out there trying their best to meet this type of need, but in addition to the problems that faced the early system-modeler vendors, new challenges such as platform interoperability, increased user sophistication, and a dizzying array of deployment choices further complicate the mix. When faced with the choice of which visual system-modeling tool to use for enterprise-level modeling and component construction, more savvy IT folks are turning to Rational Corp. and its flagship product, Rational Rose. Rose has been overhauled to provide more support than ever for busy system modelers. With the proven ability to manage the complexity of heavy design projects, Rational Rose is fast becoming the act to beat with respect to visual modeling.
I tested the Enterprise edition of Rational Rose 98 on a Pentium 200MHz machine that was loaded with 128MB of RAM and Windows NT 4.0. The 32-bit product will run under Windows 95 as well. Rational Rose 98 comprises many different utilities (or add-ins, as Rational calls them), all of which contain their own utility version number. Speaking of add-ins, you can add quite a few software modules to the core Rose modeling product during installation. Some components have dependencies, such as the Microsoft Repository add-in, which requires installation of the Enterprise version of either Microsoft Visual Basic or Visual Studio. For my installation, I took every available add-in, including support for Oracle8, Visual Basic, C++, Java, and LogicWork's (now Platinum's) ERWin modeling tool. Once you select the add-ins, the Rose installation routine then prompts you to specify a default language that you will use for new models. Designers can choose between Rose's Analysis language, C++, Java, or Visual Basic. Once I made this choice, the Rose installation process completed without any problems on my test machine and consumed a little more than 83MB of disk space.
Rational Rose C++ Analyzer comes with the Enterprise version of Rational Rose 98. You can use it to extract design information from a C++ application's source code and then construct a model representing the application's logical and physical structure. Rose is accompanied by release notes and a tutorial on using the Unified Modeling Language (UML). Unfortunately, when I tried to invoke the UML guide, Rose produced an error stating that the file needed by the NT shortcut could not be found. Many of you might be unfamiliar with the UML and its importance to Rational Corp. and its Rose 98 product. (See Paul Reed's "The Unified Modeling Language Takes Shape" in DBMS, July 1998.) The UML is a standard language that was conceived to assist in modeling complex software systems by using a common object-oriented notation. Originally the brainchild of Rational Corp.'s Grady Booch, Jim Rumbaugh, and Ivar Jacobson, the UML is rapidly becoming the de facto standard for describing and sharing system design data. For example, Microsoft has chosen the UML as its notation for its repository product to aid in sharing common software components among different third-party modeling and programming tools. Many other software vendors have lined up behind the UML, including Popkin and Platinum Technology. Such third-party support doesn't always guarantee success for a modeling methodology, but it does lend it more credibility. In any event, Rational Rose 98 (naturally) provides complete support for version 1.1 of the UML, so designers can create shareable component models that can be interchanged with other tools that support the UML as well.
Rose 98 is laid out in what's becoming the typical developer IDE - an Explorer-style interface that is flanked by multiple windows that contain the actual development code and models. One distinction in the Rose interface is the presence of a small window in the lower left corner that displays the documentation of the diagrams that have been selected by the modeler. (See Figure 1.)
Designers can visually model applications through the construction of use cases, which you use in the beginning of a project to capture the requirements of an up-and-coming system. Documenting the findings of a designer's analysis is quick and easy in Rose 98 and involves the identification of what Rational terms actors, objects, messages, and relationships. All the terms used by Rose 98 are self-explanatory. Actors are entities that interact with an application, for example, a cashier that uses an online financial system. Once actors are set up, designers working in Rose 98 can wind their application-specific use cases around them. Using sequence diagrams, modelers can build the visual logic that will provide the actual syntax-specific code for an application. Rose's sequence diagrammer won't turn off even mainframe programmers because it describes a single path through a flow of typical system interactions just like old paper-and-pencil pseudocode is used to do. Within a sequence diagram, Rose documents a system's objects and the relationships between them. After sketching out a scenario, you can begin to develop logically the mechanisms described in the use case. You'll require the presence of a development package such as Microsoft Visual Basic to accomplish this.
Developers interested in component modeling will be quite happy with the new features in Rational's latest offering. You can construct components and interfaces in component diagrams using version 1.1 of the UML. Complete support exists for COM/DCOM, JavaBeans, and CORBA. In addition, you can reverse engineer all these component styles into Rose 98 from existing sources. Once you model a component, you can generate it in a variety of languages such as C++, Visual Basic, or Java. And if a development team is using a shareable repository, such as the Microsoft Repository, component models may be fed into the repository and shared with other third-party development tools that support the UML and the underlying repository. Rose also includes support for model stereotypes, namespaces (which let classes in different packages have the same name), a visual differencing and merge tool that lets you compare Rose models with one another, and coloring capabilities that let developers color their classes and associations.
I encountered some very minor navigational problems during my workout with Rose 98. For example, when adding new objects to sequence diagrams, I couldn't use the "Undo" function. Instead, I had to delete them outright. But highlighting the objects and pressing the delete key wouldn't remove them; a Ctl-D combination was required instead. The help files that accompany the product are well organized; context-sensitive links are present throughout to help you find answers quickly. Personally, I prefer Rational's windows-based help files more than the browser/HTML combinations that many software vendors are shipping today. In terms of system's resources consumed by the product, any developers who want to run the Enterprise flavor of Rational 98 had better ensure their workstations have an abundance of available memory. My version of Rose routinely took more than 14MB of memory during normal use. Lastly, I was unable to get the product to crash in any way. Any errors I encountered were of my own doing and were caught by the tool quite nicely.
So does Rational Rose 98 have the strength to handle heavy-duty system modeling projects? I don't think there is any real question that it does. Everything I saw within the product screamed solid and stable, which is a terrific accomplishment for a software tool whose lifeblood is in such a cutting-edge arena. The real question is whether or not corporate development staffs will be able to produce the mindset needed to use visual modeling tools like Rose effectively. Developers and managers alike have often thought of modeling tools as nothing more than documentation aids and instead have placed much more emphasis on the volume of raw code turned out. If they put more thought into an enterprise application (with an eye set on reusing components as much as possible), then the visual modeling tool market should explode. If that happens, one thing is for sure: Rational Rose 98 will be in the driver's seat.
Figure 1. The Rational Rose 98 IDE lets a developer easily navigate complicated visual models.