Working with Omondo's EclipseUML Free Edition

In my last post I reviewed the Omondo EclipseUML Free Edition. In this post I want to present a more elaborate description/howto, allowing myself to focus a bit more on some details.

Installation

• Download eclipseUML_E301_freeEdition_2.0.0.beta.20041026.jar (free edition for Eclipse 3.0, although I tried it for Elcipse 3.1).
• Install by java -jar eclipseUML_E301_freeEdition_2.0.0.beta.20041026.jar
• Start Eclipse. You may be asked if it is ok if the automatic build option in Eclipse is switched on in case it wasn’t set already. Apparently this is needed for the Omondo UML plugin.

Features in free edition

The features supported in the free edition are listed here, of which the following aspects will be treated in somewhat more details below:

• Reverse engineering.
  • Support for generated package and class diagrams
  • Generation of class diagram all in one go
  • Customized (step-wise) generation of class diagrams
• Forward engineering

Summarizing, it is perfectly possible to start with some reverse engineering on an existing project, and thereafter continue to extend the model, while the plugin keeps the code and diagram in sync. Consequently, Omondo EclipseUML offers a so-called round-trip engineering, albeit lacking the generation of interaction diagrams (the dynamic behaviour of your application).

Reverse engineering

There is a tutorial on the Omondo website on this subject, but I found it unsatisfactory.

After installation, a “UML” item has become available from the pop-up menu that is invoked by a right mouse-click on a project. Choose “reverse engineering” and select all. You may allow Omondo UML to insert diagram related tags into your code. In general you want to confirm its question whether you want dependencies between packages being generated. Thereafter a package diagram is available. A sample diagram is depicted below:

A “cursor” in the outline window pane on the right offers easy navigation over big diagrams, as can be seen on the above picture.

By double clicking on a package, a class diagram may be generated of the classes contained in the package. The following options are available:

I opted for associations, dependencies and inheritance, ending up with the follow diagram:

The class diagrams are saved, the project package diagram is generated either merely from source code or from source code and @uml tags.

Per class the view can be customized, such as methods to be displayed, format (including return types or not, etc.), sorting order of attributes, methods and inner classes and so on and so forth. This can be done with the View selector, which can be invoked from the right-mouse popup menu.

It is also possible to build up a class diagram step-by-step, which can be useful if you are dealing with large packages. Suppose for instance we want to explore the inheritance relationships of a class called AbstractDataSourceFactory. When we right-click on this class in the explorer, we can select form the UML menu item the “inheritance explorer”, which puts this class on a canvas, together with the classes that extend this one. From there we can extent the diagram in a step-wise fashion, e.g. some dependencies. By a right mouse-click on one of the classes, you have numerous options to your avail. Here we navigate over “Dependencies”, which results in an additional pop-up with an option (called “Show Dependency”) to show all dependencies. Now you can select which dependency classes you want to be drawn onto the canvas.

The result of generating this way (part of) a diagram depicting the abstract factory design pattern from some existing code is shown below (was also shown in my previous post):

Forward engineering

A nice tutorial can be found on the Omondo website.

However, I took the opportunity to start a test project from scratch to see what the plugin could do for me.

Since comments can already be entered at this stage, it is possible to set up a complete model with documentation in the code to start out with. Needles to say that this is the preferred way of software development, although deadlines will often make this less feasible in practice.

Together with the above mentioned tutorial, I was up and running in no-time:

Conclusions

The product takes some getting used at, but then really pays off. After one day finding my way through the various menus, windows and tabs and exploring most of the options, I really got myself going and started to appreciat the package more and more, as I gradually became acquainted with its main features. Big disadvantage is that usage of the free edition is limited to projects that are not under source control, as was mentioned in my previous review already.

Finally, let me end listing some postive remarks about this product:

• Easy installation
• Works great for model driven development (see for all UML diagrams available my previous review)
• Nice tool when doing reverse engineering, class and package diagrams available in free edition, in enterprise edition generation of interaction diagrams included as well
• Allows synchronization between diagrams and code at any time
• Import of XMI files (e.g. Rational Rose), not tested
• Much more flexible than Fujaba Tool Suite
• Reasonably low CPU and memory footprint. To be more quantitative: on my 1 Ghz Pentium III laptop with 640 Mb of RAM it only showed performance problems sorting out all 28 classes implementing a given interface from 240 classes. However, this is an exceptional situation, at which refactoring should have occurred long before.