Advanced Software Technologies, Computer Associates and Aonix provide robust modeling products with distinct personalities.

by Gary K. Evans

Searching for the perfect object-oriented modeling tool? Who isn’t? Tools created by and for developers have always been ripe with promise but short on commitment; as a consequence, we’ve learned to hate them yet can’t live without them. In the past five years, the OO world has gone from a desperate dearth of tool capability to an embarrassing excess of options–16 Unified Modeling Language-based tools, at last count. Modeling ability is now as highly valued as Java knowledge because OO software at the end of the second millennium is too complex to design on paper and whiteboard. In any OO shop today, the question is not whether to use a modeling tool, but which tool to use.

To evaluate the current generation of OO modeling tools, I took a fresh look at three well-known contenders for the "Perfect OO Modeling Tool" title: GDPro from Advanced Software Technologies, Paradigm Plus from Computer Associates and Software through Pictures (StP) from Aonix. Although Rational Software claims its oft-reviewed Rose product "dominates the market for object-oriented analysis, modeling, design and construction tools," it is clear that other OO tools provide competitive features and bear exploring.

All of these tools share significant similarity: broad coverage of UML notation, multi-user development, shared information repository, integration with numerous external tools and applications, multilanguage code generation, and reverse engineering and rules-based configurability through a Visual Basic-like scripting language. Indeed, to be considered a serious player, an OO tool must have these capabilities.

But as important as all of this is, how well do these tools support their main purpose: building OO models? Is the tool usable? Is it intuitive? Can you use it 10 hours a day to capture and communicate your concepts? Does it deliver the goods in UML notation, or has the vendor cheated a bit?

I chose to concentrate on how each product handles the core UML diagrams for use case, class, sequence and state. If an OO CASE tool can’t handle these well, how it handles the other five UML diagrams isn’t even worth considering.

GDPro version 3.2

GDPro is the newest product in this review. First released in September 1997, it is now at version 3.2, with 4.0 beta nearing the market at press time. I was not able to review the 4.0 beta, but the promised features are enticing.

GDPro manages its UML 1.0-compliant models in a "system." Creating a system is a one-step operation, and GDPro automatically prompts you for the initial diagram and name to create. Like the other products in this review, GDPro’s diagrams are accompanied by a tool palette appropriate for that diagram. These tool palettes are colorfully designed and fully populated.

After just a little use, I found myself easily zeroing in on the correct toolbar icon based on the color keys used. A simple click on the icon selects that modeling element, and a click on the drawing window creates an instance of that element.

GDPro 3.2 Workspace

Use-case diagrams are always fairly straightforward, and GDPro did quite well at managing the use case ovals and actors. The only major feature missing here is the ability to link a use case oval to an external use case description file (say, in Word). I found a key to GDPro’s design philosophy in working with use case diagrams: I could draw communicates-association lines in the diagram, unattached to any actor or use case oval! This stunned me. Investigation in other diagrams demonstrated the same unusual "semantic-less" behavior.

I discovered that GDPro follows a modeling philosophy that supports a rather loose association of information elements rather than the rigid UML semantics found in Paradigm Plus and Software through Pictures. In this sense, GDPro is more user-centered than UML-centered. And this permissive approach is illustrated in other areas of the product. The Primitives toolbar lets you place general graphics drawings and text on any diagram. This is a natural consequence of GDPro’s evolution from AST’s Graphical Designer product. It is also a logical consequence of GDPros’s flexible approach toward UML modeling: Keep the modeler correct on UML, but don’t limit him or her to just UML. You can also use the Insert Object… feature to literally place any object you can think of directly onto a GDPro diagram. For the UML purist this is heresy, but for those of us trying to communicate complex ideas in any way we can, it’s another useful tool in our toolbox.

Setting up the class diagram was easy. Clicking on the diagram window dropped down an empty classbox. The Class Association toolbar icon lets you draw your associations. To change the association to aggregation or composition, you open the Association Properties dialog. This is also where you set a wealth of other information about associations, and I had to conclude that the data-entry mechanisms in GDPro are its Achilles’ heel. Most data is entered not through the diagrams but through data-entry dialog boxes. Even once you have opened these dialogs, you must click a "Modify" button to actually enter or edit a data field. This is very tedious when doing a diagram with 30 classes on it. (I am glad to say that some of this has been corrected in the 4.0 beta.) For example, to set multiplicity on an association, aggregation or composition, I must go through two dialog boxes. The second dialog requires me to manually enter the LowerBound and UpperBound on my multiplicity. This is wholly unnecessary. A single dropdown list box would make all of this much easier and less error-prone.

I discovered that, of the tools reviewed here, only GDPro allows me to put multiple copies of a class box on a diagram. This is a nice convenience in very large diagrams where I would otherwise have to draw long, serpentine lines to connect other classes with a single associated class.

Sequence diagrams in GDPro puzzled me. I could not drag a class from the browser window into the sequence diagram window, but I can direct GDPro to automatically populate the diagram with all my classes. As I created objects and messages between the objects, I discovered that I could "rubber band" a group of message lines and move them up or down in the diagrams as a group, but I could not move a single message line! GDPro does not support message-line numbering, but I was delighted to find that it will automatically add my messages as operations in the receiving class.

Setting up a statechart in GDPro was fairly intuitive. GDPro only directly supports events and actions as semantic elements and does not distinguish state activities from actions. This is not a problem except for UML purists, but I was disappointed that I am forced to manually enter the predefined UML keywords "entry," "exit" and "do" as events. Aside from this annoyance, guard conditions are supported within states, and creating composite (that is, nested) states was remarkably easy. The substates became linked to the composite state, and I could move them all as a group.

GDPro 4.0, which released in December 1999, has several enhancements that will significantly benefit modelers:

• Improved text formatting. Fonts were often inconsistent in version 3.2 when zoomed in or out. 4.0 looks great.
• On-diagram data entry. All of the diagrams I tested allowed single-click, on-diagram entry of visual data. A major step forward on the user interface.
• Undo/redo: These actions are virtually unlimited now.
• Sequence Diagrams greatly improved. Supports object names at top of diagram for visibility when scrolling, and a "message-spreader" opens space between messages lines, allowing new messages to be inserted.
• Orthogonal (squared) links. These are now supported on all diagrams.

The Young Colt

GDPro has been consciously nurtured for the Windows NT environment. As a result, it’s rather unstable under Windows 95. But despite its youthful shortcomings, GDPro is the aggressive young colt in this tool horse race. Its flexibility in graphical expression sets it uniquely apart from the other, more mature, products in this review. Its user interface needs significant reworking in the places where the modeler enters data into the system, and on-diagram editing is the exception in GDPro, not the norm. But its facility in allowing me to supplement the UML notation by placing additional information or graphics on a diagram is a great feature.

Paradigm Plus version 3.6.2

Paradigm Plus is a playground for the guru technician. The recurrence of the term "meta-model" throughout the Help files can intimidate the faint of heart–and even hardcore modelers. (If you need a computer dictionary to understand the explanation, have you really been helped?) But despite the high-brow geek-speak, Paradigm Plus has a consistent design philosophy and usability profile.

To use Paradigm Plus, you create a project and specify the modeling notation you want to use. Paradigm Plus supports eight notations, or paradigms: UML, Booch, Rumbaugh (OMT), Fusion, Coad/Yourdon, OOCL, OOIE and Shlaer-Mellor. Within a project, you create the diagrams appropriate for its paradigm. Paradigm Plus supports all nine UML diagrams and adheres to the UML 1.1 specification.

Creating diagrams within a project is as easy as selecting "Diagram|New" on the menu bar. The new diagram appears to the right of the browser window, and you’re ready to roll. Each diagram has a tool palette hosting icons appropriate for that diagram. Click first on the icon, then in the diagram window, and that model element appears.

Paradigm Plus Workspace

The browser window is a complete view into the mass of information maintained by the Paradigm Plus repository. Many operations that can be performed in a diagram window can also be performed directly in the browser window. Paradigm Plus excels at allowing you to specify and filter what you want to see, or not see, in a diagram, or even in a single-model element, but the browser window always makes everything available for you.

Use case diagrams have no surprises, although the special actor icons for Human, Software and System seem unnecessary. Use case names can be edited in-line, and both the UML 1.1 <<extends>> and <<uses>> relationships are supported. External use case description documents can be linked with the use case symbols, but, in an annoying omission, Paradigm Plus does not offer a Browse… button to search for the document; you must manually enter the full path name.

Class diagrams are intuitive. Classes can be dragged from the browser window and dropped into the diagram. When two classes are joined by a Relationship line, a pick list immediately appears from which you can select Association, Aggregation, and so on. Inheritance lines are automatically squared, which is nice, but this can be easily overridden if you prefer oblique lines.

Sequence diagrams present several special challenges. When creating a sequence diagram, you cannot simply drag and drop a class name from the browser. This is because Paradigm Plus rigorously enforces the UML semantic restriction that a sequence diagram contains only objects, and a class is not an object. To add an object to a sequence diagram, you must open the Object dialog box, pick a classname from a list box and give the object a name. Also, Paradigm Plus will not allow you to create an anonymous (unnamed) object. This is an exception to UML syntax, but Paradigm Plus disallows this because its repository references objects solely by their name,.

Should you want to insert several messages into the middle of a diagram, you’ll trip over the biggest flaw in Paradigm Plus’s sequence diagram. If you need to move multiple lines down the diagram to make room, you must move these one at a time. It is theoretically possible to move multiple lines as a group, but only if every line in the selected group exactly touches an object lifeline–a very precise and difficult alignment. For practical purposes, you can’t do it. If you have 100 tightly-packed messages and need to insert a new message after the fifth, for example, you have 95 message lines to move one at a time.

Statechart diagrams support both simple and nested states. A very nice feature is the ability to drag a class from the browser and drop it onto a statechart. Resize the class box so that it is very large, then add states and transitions inside the class box. This will produce a semantic coupling between the class and its states. Entry and exit actions are supported directly, but activities (denoted by "do/…") are not. Again, Paradigm Plus follows the dubious UML 1.1 semantic stating that activities should be on activity diagrams because "activity diagrams are a special type of statechart." I disagree with the UML’s emphasis here; activities are performed by a class, but activity diagrams have no connection to any specific class. I regret that Paradigm Plus has followed the UML in this area.

All Paradigm Plus models support strong semantics; in other words, Paradigm Plus won’t let you model something unless it follows the UML meta-model definition.

Ironically, because of Paradigm Plus’s precision in getting the semantics right, I was able to create modeling relationships that have little business value. On use case diagrams, Paradigm Plus allows you to draw communicates associations from actor to actor–a dubious achievement, since actor-to-actor relationships are out of scope in a use case. Paradigm Plus also allows you to draw communicates associations from an actor back to itself.

When adding the predefined UML multiplicities (*, 1..*, 0..1) to an association or aggregation, you can edit the multiplicity directly on the diagram or in the Multiplicity field of a Properties dialog, but not for numerically specified multiplicities (1, 2-4, 8). These are treated as constraints and must be entered into the Constraint field of the Properties dialog. What’s more, constraints override any existing multiplicities. This can be very confusing at first, and I still don’t like the way it works. It matches the meta-model, but it doesn’t help me get my work done in a seamless way–it actually resulted in my model being incorrect until I discovered what Paradigm Plus was doing.

The Thoroughbred

If you use Paradigm Plus, you will have to learn about meta-models. This is not necessarily a bad thing. But if your goal is simply to get work done in your business domain, it might seem at first as if Paradigm Plus were putting obstacles in your path. Fortunately, you can use Paradigm Plus quite productively without taking a graduate course. Paradigm Plus is a thoroughbred, not a draft workhorse. It is elegant and precise–sometimes to a fault–but has all the horsepower you need to get the job done.

Software through Pictures version 7.2

Aonix Software through Pictures (StP) is designed for large projects, so much so that it does not even run in Windows 95 or 98. It has a long history in large government and military projects–which accounts for its broad support across many Unix platforms–and Windows NT 4.0. Version 7.2 is brand new, faster, lighter and friendlier than earlier versions and is a pleasure to use. It also supports the UML 1.1 specification.

StP Desktop and Class Editor

Unlike GDPro and Paradigm Plus, StP does not present itself as a single monolithic application. It is a suite of many collaborating applications: the StP Desktop, the Diagram Editors and the Table Editors, among others. It feels noticeably different due to this architecture. Starting an Editor causes a pause as StP loads the application. The segregation of many diagram details into the Table Editors makes the information within a diagram disjointed. For example, to add visibility specifiers to attributes and operations of a class, you must invoke the Class Table Editor and enter this information there. It cannot be entered directly into the Class diagram. On the upside, Aonix’s choice to load information into Tables on demand simplifies the integrity management of the StP repository. When I load a Table Editor, I am sure to get the latest information in the repository.

When you start StP, you see the concise desktop window. This is the home of report generation, code generation and reverse engineering. The OO diagrams you create from the desktop reside in a "system." Creating a system is an easy, one-step process from the desktop window. Once the system is created, you create new diagrams using the Diagram Editors.

Use case diagramming is very simple, and like the other diagram editors, a toolbar provides icons appropriate for the type of editor. StP allows you to set up names and icon sizes the way you want them. StP also lets you apply user-specified stereotypes to your actors, which I have found to be very important in clearly distinguishing actor responsibilities. As with GDPro, StP’s major omission in this area is that you cannot link a use case symbol on the diagram to a use case description document. This is unfortunate, since the UML use case diagram alone has little business value; all the important information resides in the use case description document.

The Class Diagram editor is very intuitive. I can create classes and add attributes and operations by clicking on the appropriate toolbar icons. StP supports the widest range of UML class diagram adornments of any of the products I reviewed, including N-ary relationships, parameterized classes and bind arguments, and "or" associations. Notational horsepower notwithstanding, I was surprised to find that I could not change the font family used in the diagram, set colors in the diagram icons or change the location of captions on association lines.

Setting relationships between classes reveals the architectural personality of StP. On any StP diagram, you establish a relationship between model elements by drawing an arc–a tool bar icon in every Diagram Editor. In a use case diagram drawing, an arc between an actor and use case is rendered as a communicates association. Drawing an arc between a use case and another use case is displayed as a <<uses>> or <<extends>> relationship, depending on the Default Arc definition, which is user-specified.

In a class diagram, I set the Default Arc definition to "association." Every relationship I subsequently drew between classes was rendered as an association. To specify that some of these relationships were actually aggregation, composition or generalization, I had to select each association and open its Association Properties dialog box. This dialog–and not the actual diagram–is where you specify detailed information: stereotypes, multiplicity, qualifiers, aggregation/composition, navigability, and so on. StP does not support on-diagram editing or specification of multiplicity, roles, and so forth. You must do all of this through Properties dialog boxes, and it’s rather tedious. For example, multiplicity, which should always be specified, must be manually entered. I was very disappointed that Aonix has not put a dropdown list box on this field, since all multiplicities except "numerically specified" are predefined in the UML.

Sequence Diagrams support anonymous objects, and adding objects to the diagram is very easy through a pick list supplied by StP. It’s possible to move groups of message lines with the UML|Shift Messages selection. You can also assign sequence numbers, sort on those numbers or change the sequence ordering. In addition, you can direct StP to automatically transfer messages into operations in the receiving class. But despite these solid capabilities, there is no easy provision for placing scenario text on the sequence diagram. Go figure.

In the Statechart Editor, creating state icons and transitions between states is very simple until you try to add actions, activities or guard conditions within a state. These must be entered through a State Table Editor, and the actions do not ever actually appear on the State diagram! Only a table display mark is shown on the state icon, a reminder to look for the state details someplace else.

The Workhorse

Despite its few quirks, this version re-affirms StP’s reputation as a workhorse. To get the maximum benefit from StP, you will have to customize it, but it has been designed to be highly customizable. Although its user interface needs some tuning, and there is a learning curve for figuring out whether to go to a Diagram Editor or Table Editor, StP is mostly consistent in its personality. And while StP has the most comprehensive coverage of UML notation of the products reviewed here, what’s more important to note is that it has few proprietary extensions to the UML.

Waiting for the ideal tool

Any of these modeling tools will help you meet your goals of organizing information and managing project complexity, but each brings its own distinct personality to the table and makes its own demands on you to use it successfully. GDPro has more of a free-wheeling personality than the other two products, and, while version 3.2 has impressive features, its user interface has too many inconsistencies for me to want to wrestle with it 10 hours a day.

Paradigm Plus has consistency built in as a virtue, and it does offer you the option of either diving into the depths of its repository meta-model or just building models without using 75% of its supporting functionality. Finally, StP is a product with staying power and is a major OO tool on Unix platforms. Its emphasis on Table Editors, however, suggests an older, more data-centric approach.

Of course, none of these is the perfect object-oriented modeling tool developers are seeking. But if this roundup found an aggressive colt, a refined thoroughbred and a draft workhorse, I’ll bet there’s a new contender about to enter the field. I’m still waiting for a champion.