|
|
|
Software development is in large measure all about communication -- communication between programmer and machine, between programmer and user, and between programmer and programmer. Although CASE tools can be useful in facilitating all three types of communication, it's in the arena of enabling and enhancing communication among developers where these tools really shine. In this trio of reviews, I look at Platinum Paradigm Plus version 3.5, Select Enterprise version 5.0, and Rational Rose version 4.0.
Each of these tools, as you can see from the version numbers, has been through the wringer of early versionitis. Most of the rough edges are gone, and the resulting tools are strong contenders for your enterprise development attention. The Select and Rational offerings have received more attention over the years than the Platinum tool, so I've focused more on the feature set of Paradigm Plus. What differentiates these tools more than features or ease of use is the philosophy driving the development of each tool. After I've discussed each tool, you'll have a better understanding of how those philosophical orientations are manifested in the tools.
Thus, although you can't, for example, take a diagram created with the Coad/ Yourdon notation and display it in OMT, you can export the Coad/Yourdon diagram to an intermediate file and then import from that intermediate file into OMT. Currently customers may only use those modeling notations (paradigms) supported by Platinum. However, a tool now under development will let the customer develop custom "paradigms" to meet individual needs.
By and large, a CASE tool stands or falls on the strength of its repository and on how well that repository is integrated into the tool and supporting utilities. Once that is achieved, overlaying that repository with a set of diagram editors is not difficult. Indeed, all of the diagram editors found in these three tools offer identically superior image-manipulation capabilities. Thus itemizing the methods and notations supported specifies by reference the diagram editors available for each. An interesting twist from Platinum is the "cheat sheet" diagram included in every project. (See Figure 1.) If you need to remember the subtleties of how an aggregation should be depicted in OMT, you need only open the OMT Notation diagram for a quick reminder. And for an evolving notation such as the UML, the cheat-sheet approach, combined with the scripting language (which I describe later), gives Platinum an effective way of quickly disseminating new notations -- and documentation -- to its customers.
As befits a tool supporting several object-oriented modeling techniques, the underlying Paradigm Plus repository is based on Object Design's ObjectStore object-oriented database management system (OODBMS). Aside from the elegance that an object-oriented repository affords, it provides other advantages: For example, Platinum includes utilities and APIs that enable the user to maintain and access the OODBMS from the command line or from external, user-written programs. The repository can thus be integrated into the organization's software development life cycle (SDLC). And further enterprise integration is facilitated because Paradigm Plus uses the same repository for Unix, OS/2, and Windows versions of the product.
Because the software design process requires creativity as well as engineering, developers must be able to explore alternative approaches to solving the problem at hand. However, the integration of Paradigm Plus with its repository results in all changes to the current design being immediately stored in the repository. How, then, can a user back out of a series of design decisions that turn out to be a dead end?
Platinum has provided two alternative solutions. First, because objects modeled with the tool are stored as components within the OODBMS, and because the ObjectStore repository provides versioning, the user can check out a component -- usually an object -- and create a new revision. If the effort of creating that new revision turns out to be a dead end, the user can start over and create another branch from the base version. The other solution is that you can turn off automatic synchronization in Paradigm Plus. Thus, if you elect to utilize this approach, your changes are not committed to the repository until you are ready to commit them. The disadvantage is that any design effort expended while auto-synchronization is turned off may be lost if your workstation crashes.
In addition to the elegance that the ObjectStore repository brings to Paradigm Plus, the tool's script-based command architecture deserves attention. In most CASE tools -- as well as in most consumer software -- the commands executed when menu items are selected are hard-coded into the executable. In Paradigm Plus, however, the majority of available commands are implemented as scripts. You can modify these scripts and create original scripts and assign them to new menu choices.
The scripting language forms such an important part of Paradigm Plus that a significant portion of the documentation is devoted to explaining it. The BASIC-like language includes functions to access the repository and all diagrams; you can read the information resident in the repository and in the diagrams, and you can also use the scripting language to create new repository objects and create and manage diagrams. In addition to creating scripts that can be run on demand, you can also create scripts that run when events occur in the Paradigm Plus environment. For example, you can make a script fire whenever you create a new class.
The language provides all of the features -- such as typed variables and arrays, file input and output, and flow control -- that you would expect to find in an implementation of BASIC. In addition, however, a library of functions provides access to specific Paradigm Plus features. You can also access the underlying operating system from within the scripting language, if you want to run external editors or perform file management.
Platinum Paradigm Plus provides four separate but integrated views of the repository. The first, and most obvious, is the view found in the diagrams; this is the view most people expect from a CASE tool. In addition to diagrams, however, you can access the repository using the object browser, a table editor, or a matrix editor. The object browser lets you view the repository using a three-pane interface that resembles the now-familiar Windows 95 Explorer. That is, the repository contents are displayed in the left windowpane as a hierarchy, with the project as the root node and the classes subordinate. The right pane displays the properties of the selected object, and a pane spanning the bottom provides a text-editing window.
The matrix editor gives you a tool for maintaining the links among objects in a project. These links may take the form of either aggregate or association relationships. With this tool you can, for example, display a matrix consisting of classes in the x dimension and attributes in the y dimension, with checkmarks indicating links between classes and attributes. The table editor lets you display all members of a given metaclass (such as classes or processes), along with their properties. You can use this tool to compare properties of several metaclass objects in the same window. The object browser and the table editor display much the same information, but the table editor focuses on the hierarchical relationships of the objects in the repository, whereas the table editor offers a convenient way to examine the properties of several objects at the same time.
One of the advantages of using a CASE tool over a diagramming tool is found in how well the tool enforces the rules of the method you are using. With a diagramming tool, all model checking must be performed manually by the developer. Paradigm Plus provides some of the most complete model-checking capabilities available, thus helping the developer ensure that his or her model is logically consistent.
For the database programmer, Paradigm Plus offers several advantages, but most important, it provides an automated facility for mapping relational tables to objects. Persistent attributes of objects map directly to table columns. Because Paradigm Plus maps attributes to columns bidirectionally, it can help object-oriented programmers and data administrators get on the same page and speak the same language.
In addition, the Paradigm Plus reverse-engineering capability is the most robust of the tools reviewed here. It does a much better job of automatically placing objects generated from the reverse-engineered database on the drawing surface in a usable manner. Many tools that claim to reverse-engineer existing databases do so; however, most tools making this claim fail to do a competent job of creating clean, human-readable, diagrams with a minimum number of spaghetti-like connectors between entities or objects. The logic that Paradigm Plus uses to place re-engineered objects is significantly superior to that available from other vendors.
As with the other tools reviewed here, Paradigm Plus enables the user to generate SQL from the data models. The elegance of the scripting language is further revealed in how new datatypes can be added to SQL generation, a feature that will take on increasing importance as customers adopt object-relational database hybrids.
Once a design has been created, committed to the repository, and transformed from object to relational, you can generate code for C++, but interestingly, Paradigm Plus also supports generation of Active X and Netscape Plug-In components. In addition, code generation for Platinum's ObjectPro tool is supported; ObjectPro competes with PowerBuilder and Visual Basic in the RAD tool marketplace. Paradigm Plus supports round-trip engineering (RTE), as do the other two tools discussed. RTE enables the developer to import existing code and database schemata into a new physical model, from which a first-cut analysis model may be constructed.
OMT provides an excellent set of notational tools for describing a program or system from a analysis or programming perspective. However, the strength of competing methods such as information engineering lies in their ability to help the analyst describe how multiple systems interlock in a large organization. Select addresses that need by layering business process modeling on top of "standard" OMT. You can then link various OMT objects resident in the dictionary to specific business processes.
This layer is not an afterthought. Included with the Select Enterprise package is a slim volume by Select founder Stuart Frost that outlines the "Select Perspective." Although you can use Select Enterprise without reference to the Select Perspective, doing so ignores the effort -- unique among the tools reviewed here -- put forth to expand system modeling from a collection of unrelated systems to an integrated hierarchy of cooperating systems. This approach affords several advantages, including promoting reuse of components throughout the enterprise.
Frost describes the Select Perspective as beginning with an architectural model in which collections of local business objects (LBOs) are subsumed by collections of corporate business objects (CBOs). Frost suggests that Select users take a four-schema view of their enterprises in which the architecture consists of LBOs, CBOs, interface objects, and storage objects. (See Figure 2.) If you follow this prescription, you'll adopt an additive approach to modeling: You begin with a CBO model, around which you build an LBO model. The interface and storage object models occupy successive layers, and the outermost layer consists of the code used in building the system.
Select Enterprise supports C++ code and SQL schema generation. In addition, round-trip engineering is also supported, which enables the user to utilize existing code and schemata. A unique feature of Select Enterprise is the Object Animator. This tool lets you dynamically observe the behavior of object interaction diagrams, a particularly useful feature when verifying design correctness with users and managers.
From a database programmer's perspective, the schema generator is one of the more important tools included with Select Enterprise. You will recall that storage objects are defined in their own phase of the Select Perspective method. These storage objects are designed from the get-go as tables; they are not mapped to objects. The Select schema generator supports Oracle 7, SQL Server 6.0, SQL/89, and SQL/92.
Using Select is, in general, an intuitive process, with only a few surprises lying in wait for the unsuspecting developer. The most important of these is that Select Enterprise commits all changes directly to the dictionary and lacks an undo command. Thus the only way to experiment on a project is to save the project under another name and work with that project. Then, when the desired changes have been explored and defined, you must close the duplicate project and recreate the changes in the live project. Fortunately, Select lets you manage duplicate versions of the same project from within the tool. However, these versions cannot be merged.
Select is available only for Windows. This is a blessing -- and a curse -- because the Windows-centric orientation means that Select Enterprise can, and is, built to take advantage of OLE. For example, document generation from within Select is accomplished by means of Microsoft Word templates.
One of the most significant differences between Rose and the other tools I've examined in this review is that Rose has a minimal repository. The Rational viewpoint, as it were, is that the diagrams should stand alone and represent the generated code. Thus, sharing on the project level is not supported, unless the project can be represented in one diagram. This philosophy lies behind the assertion that Rose should be considered a programmer's tool. It should be noted, however, that Rational is working to integrate Rose with Microsoft's Repository. This will bring much-needed team programming capabilities to this tool.
Rose is available in several versions for generating C++, including Windows and Unix. Other versions are available for generating PowerBuilder, Visual Basic, Smalltalk, and Ada.
The real strength of Rational Rose lies in its ability -- far greater than that of any other tool discussed here -- to tie the design to the code. As you can see in the accompanying screen shot (see Figure 3), when you specify a class, the tabbed dialog box gives you access to very granular details about that class. The choices you make when you specify these details are what drives the code generator.
Another instance of Rational's programmer-centric philosophy is found in its support for configuration-management tools such as Intersolv's PVCS. These tools, most often used for managing source code archives, are not optimized for use with CASE diagram files or repository contents. Yet because of Rational's minimalistic approach, the Rose files work well with the source code management tools. A side effect of Rose's file-centric approach is that it makes it difficult for multiple developers to work on the same model because only one developer can check out a model file at a time. The flip-side advantage is that this approach makes it easier to implement differencing tools to aid the developer in comparing versions of a model.
Unfortunately, because Rose was developed by a consulting company, as opposed to a software company, the tool has not been grown in a consistent and unified manner. For example, rather than enhancing the basic tool to provide support for a variety of target platforms -- such as C++, Visual Basic, Forté, and Ada -- the company spins off new versions of the product for that platform. As a result, if you are working with C++ and then want to work with Visual Basic, you have to export your files from Rose/C++ and then import them into Rose/VB. A new scripting language is supposed to address this deficiency, however.
The haphazard manner in which the tool has been grown has also affected the tutorial and reference materials supplied with the tool. Although the documentation has been improved over previous versions, the tutorial material is woefully weak. It might be more accurate to say that the tutorial material is nonexistent, because each of the tutorials included in the distribution caused Rose to abort silently. In addition, no sample projects are provided. As a result, you should only consider Rose if you understand fully what you want the tool to do for you. If you don't have this knowledge, Rational will be happy for you to attend one of the company's training classes.
For the database programmer, Rose offers the weakest set of tools among the three products reviewed here. Rose's standard version does not include any database-generation tools. To generate SQL schema from the object models, you must purchase a separate tool that reads the common .mdl (model) files that Rose creates and then generates a schema. If you are counting on generating documentation from Rose, be prepared to work with rich text format (RTF) files created from standard, nonmodifiable templates. Rose documentation is further limited because you can only control what classes are included in a given report. No cross-referencing or other documentation aids are provided.
