Channels ▼

Snapshot of a UML Tool

April 2001: Snapshot of a UML Tool

In 1878, English photographer Eadweard Muybridge settled a famous bet for Leland Stanford, governor of California, founder of Stanford University and horse-racing enthusiast. Stanford bet a friend that a horse that was cantering (galloping at a fast trot) kept at least one hoof on the ground at all times. At a racecourse in Palo Alto, Muybridge set up 12 cameras at trackside with shutters activated by tripwires. The resulting motion pictures proved that the horse did indeed raise all four hooves off the ground while cantering.

Muybridge's stop-motion studies came to mind a little more than a year ago when I read Gary Evans's review of GDPro 3.2 ("A CASE Tool Horse Race," Feb. 2000). In that article, Evans commended GDPro as an aggressive young colt in the CASE tool horse race. Evaluating and writing a review of any of the current object-oriented (OO) modeling tools struck me then as something akin to a stop-motion study; the pace of the tools' development is torrid and an objective look at any of their competitive features requires the reviewer to be able to make almost snapshot observations.

First released in September 1997, GDPro is now at the version 5.0 milepost. While the 5.0 Release Notes tout the product's new and improved Java focus (which includes live round-trip engineering for Java, expanded EJB support and a JavaDoc editor), I'm convinced that in the long run a couple lesser-promoted features, such as GDPro's support for robustness analysis and Web application stereotypes, will turn out to be key differentiators for GDPro in the burgeoning UML tool market. It's equally likely, too, that database design will play a large and significant role in future releases since GDPro's creator, Advanced Software Technologies, was recently acquired by Embarcadero Technologies, who makes the ER/Studio data modeling product.

Once Around the Block
Live round-trip engineering for Java is the latest hurtle that the current generation of UML modeling tools must clear. A few years ago, TogetherSoft, lead by experienced model builder and author Peter Coad, was first out of the gate with a simultaneous round-trip engineering feature in its TogetherJ release, which let developers keep their code and UML models synchronized in real-time. But OO-modeling-tool market leader Rational Rose and several other UML tool vendors, including Advanced/ Embarcadero, have made significant improvements in reverse-engineering source code and round-tripping in their last few releases. (Reverse engineering in this context means a tool's ability to create UML diagrams from source code.) Although GDPro 5.0 is one of a handful of tools that can create sequence and collaboration diagrams, the current generation of modeling tools is pretty much restricted to reverse-engineering class diagrams from source code (you aren't able to, for example, parse a state machine implemented as a switch statement into a state diagram). Round-tripping refers to the kind of workflow that lets you work on both diagrams and code at the same time; where, for example, you might start by drawing a class diagram, then generate code from it, then implement additional features in the code, and then go back to the design, which would be updated with code changes.

Keeping Things in Sync
For a variety of reasons, I've recently come to the conclusion that simultaneous round-trip engineering is an over-rated feature and shouldn't be the make-or-break feature when deciding which modeling tool to buy. If you're using UML to gain greater visibility into an application than you have by looking at its source code, then GDPro is one tool that will help you do this well. GDPro lets you do markerless round-trip engineering, meaning you can make changes to your source or diagrams without cluttering your code with tags or markers. And—perhaps most important—you can do these changes incrementally:
You can change your model and reverse engineer either a single class, multiple classes or the entire system. Given the overhead required to constantly write code for design artifacts that you won't need at implementation, GDPro's approach, which lets you turn off the round-tripping feature during analysis and design, strikes me as a sensible, middle-ground solution.

Starting the reverse-engineering process is straightforward: You choose Tools->Reverse Engineer from the menu and choose your language option (C++, Java or IDL). The Reverse Engineering dialog box lets you filter and add additional files. Reverse engineering worked seamlessly on the sample Java application that comes with the GDPro installation, which you might expect, but I was also pleasantly surprised that GDPro could parse the code in a 9MB download of Sun's Forte for Java, Community Edition in approximately 20 minutes. That would have undoubtedly been faster had I filtered out some of the recursed Forte project subdirectories in the Reverse Engineering dialog box that didn't need to be in the model.

Figure 1. GDPro's EJB Wizard

The EJB Wizard walks you through the steps of creating a bean, including managing its state.

Spilling the Beans
GDPro's Enterprise JavaBean (EJB) support, which is new in this release, implements an interface that lets you model EJBs using UML and generate an EJB-JAR file that can be deployed on different EJB servers. You can also incrementally reverse engineer EJB-JAR files containing EJBs. An EJB wizard (see Figure 1) walks you through the steps of creating a bean, letting you specify the type (stateless session, stateful session or entity bean) and how the bean manages persistence (none, container-managed or bean-managed). Once you make these selections, GDPro creates a new "component view" by bringing in the Javaex.EJB package that you need to create the EJB, automatically creating the Home interface, Remote interface and populating the bean with the right methods and attributes. The final step, once you've created the EJB, is to launch GDPro's XML Deployment Descriptor, which you can then export and deploy with the newly created EJB on the application server of your choice.

Easier Ad Hoc Docs
For Java developers who use JavaDoc, GDPro also now has a built-in JavaDoc editor. JavaDoc is the program used to create the HTML-format Java API documentation and is distributed as part of the Java SDK. The built-in JavaDoc editor makes it easier to add descriptions to Java classes, methods and members since the editor knows the structure of predefined JavaDoc (and user-defined) tags and can enforce the tag's structure.

In addition to easing your editing effort, GDPro has also expanded reporting capabilities for getting information out of a system. You can generate five different reports for the diagrams you create: a class model report, a package report, a symbol requirements report, a diagram type report and a consistency report, which tracks consistencies, unnamed symbols, invalid relationships and symbols without graphical representation on your model. Similar to reverse engineering, GDPro's reporting process lets you select the granularity you want for the HTML, RTF and ASCII reports it creates, which means for a package report, the report scope can be "All Packages in System," "All Packages on a Diagram" or "Selected Packages." There is also a Web Viewer Report wizard that lets you generate a series of Web pages to communicate system details, properties and relationships within your model. I was pleasantly surprised by the detail in the large number of Web pages created by the Web Viewer wizard when I ran it against GDPro's Scheduling System sample application.

Avoiding "Useless" Use Cases
GDPro 5.0 now contains support for the ICONIX process [based on Doug Rosenberg and Kendall Scott's Use Case Driven Object Modeling with UML (Addison-Wesley, 1999)]. Symbols for the ICONIX Boundary class, Control class and Entity class are built into GDPro's toolbars, and you have the option of creating a "robustness diagram" when building a new model.

Software Development readers should be familiar with robustness analysis from the five articles Rosenberg and Scott authored in the December 2000, January 2001, February 2001, March 2001 and April 2001 issues. Those articles provide a prepublication look at their follow-up Applied Use Case Driven Object Modeling (Addison-Wesley, 2001; tentatively scheduled for June). Rosenberg and Scott's new book shows common mistakes that developers writing use cases are likely to make, and then explains how to correct them.

Doing robustness analysis with a tool like GDPro will help keep you from writing "useless" use cases—a trap you can fall into with a more code-focused UML modeling tool (see Sidebar: Avoiding "Useless" Use Cases). As Rosenberg points out in his book, the advantages of robustness analysis are that it offers a streamlined or "minimalist" approach to UML, and it keeps you from straying too far from the user's needs during various analysis and design steps.

GDPro 5.0 also supports the Web Application Extension (WAE) stereotypes that Jim Conallen has popularized (see "Modeling Web-Tier Components," Beyond Objects, Jan. 2001). WAE extends the basic UML notation with architectural elements (server page, client page, frameset and so forth) that make it easier to model Web-specific applications.

I did find one or two shortcomings in GDPro's approach to associating diagrams. At one point while putting GDPro through its paces, I attempted to associate a specific WAE stereotype with a boundary object on robustness diagram. My idea was to associate a Web-specific security feature—for instance, an SSL-connection, with a boundary object on a robustness diagram—to call attention to the fact that the certain level of security was a prerequisite for the Web application I was modeling (to, in effect, use a stereotype to define a top-level precondition). Fortunately, I was able to associate my custom stereotype with the boundary object I wanted, but only with the helpful assistance of the Embarcadero Technologies Technical Support hotline, who walked me through the various dialog boxes and property sheets (see Figure 2). I would like to see a different approach to associating diagrams and objects in future GDPro releases, perhaps something more drag-and-drop or diagrammatic, rather than dialog box-driven.

Figure 2. Dialog Box for Associating Items

It's necessary to double-click on the Associate button to bring up a dialog box with a listing of diagrams and symbols.

Scoping Requirements
GDPro also has an integrated internal database of flat-file format requirements, which you can use stand-alone to collect and manage requirements or integrate with other requirements tools such as Telelogic's DOORS ( or Technology Builders' Caliber-RM ( You can opt to associate a requirement with one or more symbols or model elements (such as use cases) or diagrams. You can also run synchronizers from within GDPro to refresh the list of requirements from either DOORS or Caliber-RM to update the list of changed or added requirements. Since I didn't have either DOORS or Caliber-RM on my test machine, I couldn't test this feature, but the process seems fairly self-evident. The OO database repository at the heart of GDPro is Poet Software's zero-administration OODBMS, which provides the object-level locking necessary for work-group collaboration—enabling developers, analysts and designers to work on the same application or diagram at different locations simultaneously. Geographically dispersed teams are also supported by GDPro's integration with leading configuration management and version-control tools, including Continuus, PVCS, ClearCase and others.

How It Stacks Up
Other UML tools besides GDPro also support Web application stereotypes and robustness analysis. Rational Rose offers a WAE add-in for Web modeling and Jim Conallen, the creator of WAE extensions and a Rational employee, has numerous Rose scripts and examples in his 1999 book Building Web Applications with UML (Addison-Wesley). ICONIX offers Rose scripts and instructions on doing robustness analysis in Rose on its Web site ( Despite this, for my money, GDPro's support of these two new and innovative modeling approaches is second to none. It's sure to be particularly popular with developers looking for a tool that lets them work at a high level of abstraction than the more code-focused UML tools while using a minimal but sufficient core subset of UML. GDPro may not be the "aggressive young colt" that it was in an earlier release, but it's definitely a UML modeling tool that is saddle-broken and ready to be ridden.

GDPro 5.0

Embarcadero Technologies Inc.
7851 Elati St., Ste. 102
Littleton, CO 80120
Tel: (303) 730-7981
Toll-free: (800) 811-2784

Price: Windows platforms $2,995 per user (includes one year of maintenance); Unix platform $4,795 per user (includes one year of maintenance)

Technical Requirements:

Windows NT 4, 95, 98; Sun Solaris

minimum Pentium 266, 64MB RAM

RATING: **** The Rate Sheet
  1. Supports Web application extensions (WAE) stereotypes and robustness analysis.

  2. Supports EJBs and includes a JavaDoc editing tool.
  3. Supports markerless round-trip engineering and reverse engineering.

  1. Needs a simpler way to associate diagrams.
  2. A tutorial on robustness analysis would be helpful.
  3. A tutorial for WAE stereotypes would also be nice.


Avoiding 'Useless' Use Cases

Here is a real-world example of a "useless" use case that a developer friend of mine recently tried to decipher. The use case is designed to support a financial portfolio management application:

"Use Case: Planning and operation of the portfolio may be done by the same person in many companies. Even if that is the case, separating them out gives us the ability to allow the client to split these roles. It also correctly mirrors the actuality of the situation even if the same person is doing both: A person wearing multiple 'hats' is actually going in and out of different 'roles.' Operate portfolio encompasses all aspects of execution, as opposed to strategy (define) or tactics (plan)."

Another programmer (who was not a software architect) wrote the "useless" use case above using a code-focused UML modeling tool, and it's fairly obvious that the text of the use case isn't in the proper noun-verb-noun business English format. The actors and potential domain objects are also difficult to identify in this example. Although abbreviated here, the rewritten use case below has much clearer and discrete syntax and can be used much more productively by an application developer.

Use Case Specification: DesignOffer
1. Use Case Name: DesignOffer
1.1 Brief Description: This use case encompasses the task of visualizing and defining an Offer as part of a portfolio.
2. Flow of Events
2.1 Actors: CreativeDesigner
2.2 Basic Flow
2.2.1 Step 1: Define the Offer.
2.2.2 Step 2: Create the text elements.
2.2.3 Step 3: <<extends>>CreateVisualElements.
2.2.4 Step 4: <<uses>>DevelopOfferRules.
2.2.5 Step 5: Insert Tag references to Rules.
This use case ends when the system accepts all inputs from the CreativeDesigner for the Offer's basic information.
2.3 Alternative Flows
2.3.1 Test Offer using Rules
2.3.2 < Second Alternative Flow >
3. Special Requirements
3.1 Incorporation of third-party visual editing tool
3.2 Development of basic Offer template libraries
3.3 Development of ad hoc testing capability
4. Preconditions
4.1 A portfolio has already been established for this Offer
5. Postconditions
5.1 A new Offer has been defined in the system, including rules, text and (optionally) graphic templates.
6. Business Rules
A listing of conditional logic or business and regulatory policies that affect the use case, by executing an alternate flow or extension point. (Additional alternate flows and extension points listed separately.)

—by Roger Smith

Related Reading

More Insights

Currently we allow the following HTML tags in comments:

Single tags

These tags can be used alone and don't need an ending tag.

<br> Defines a single line break

<hr> Defines a horizontal line

Matching tags

These require an ending tag - e.g. <i>italic text</i>

<a> Defines an anchor

<b> Defines bold text

<big> Defines big text

<blockquote> Defines a long quotation

<caption> Defines a table caption

<cite> Defines a citation

<code> Defines computer code text

<em> Defines emphasized text

<fieldset> Defines a border around elements in a form

<h1> This is heading 1

<h2> This is heading 2

<h3> This is heading 3

<h4> This is heading 4

<h5> This is heading 5

<h6> This is heading 6

<i> Defines italic text

<p> Defines a paragraph

<pre> Defines preformatted text

<q> Defines a short quotation

<samp> Defines sample computer code text

<small> Defines small text

<span> Defines a section in a document

<s> Defines strikethrough text

<strike> Defines strikethrough text

<strong> Defines strong text

<sub> Defines subscripted text

<sup> Defines superscripted text

<u> Defines underlined text

Dr. Dobb's encourages readers to engage in spirited, healthy debate, including taking us to task. However, Dr. Dobb's moderates all comments posted to our site, and reserves the right to modify or remove any content that it determines to be derogatory, offensive, inflammatory, vulgar, irrelevant/off-topic, racist or obvious marketing or spam. Dr. Dobb's further reserves the right to disable the profile of any commenter participating in said activities.

Disqus Tips To upload an avatar photo, first complete your Disqus profile. | View the list of supported HTML tags you can use to style comments. | Please read our commenting policy.