Ben Northrop

Decisions and software development

The Search for a Good UML Tool

October 26th 2006

Over the past couple weeks, I've dug into a few of the more popular UML tools out there, hoping to find out which to use at either end of the complexity spectrum, the small startup or the big corporation. What I found is that such a quest isn't so straight-forward. There are entirely too many UML tools to choose from, and it's amazing (at least to me) that a little marketplace natural selection hasn't yet weeded out the good from the bad from the ugly. But such is the state of the UML world: chaotic...and as I found out, a bit disappointing. In the end, however, there are some good alternatives, but not surprisingly, one size does not fit all.

My Approach
With so many tools on the market, it's just not possible to look at each one. [1] Instead, you've got to define your requirements up front, and then take a reasonable sample and see if you can find one that satisfices. This was my approach...

Breaking it down, developers essentially need a UML tool for three things: (1) to design something from scratch, (2) to understand some existing piece of code, and (3) to maintain documentation for an existing system or component.

For each of the these "use cases", different features are required from a UML tool. When designing from scratch (use case 1), I need the tool to help me easily create different perspectives of the system, share these diagrams with my colleagues, and perhaps forward engineer these diagrams into source code. When using a UML tool to understand some existing piece of code (use case 2), I need the tool to reverse engineer my code (without sucking the life from my computer), and then let me drill into the model to understand the relationships or structures that are germane to my task. And finally, when I'm maintaining documentation for an existing system or component (use case 3), I would like the UML tool to reflect any changes in the source code from the last time I've opened my model. For example, if I create and save a diagram at time T1, change the underlying source at T2, and then reopen my model at T3, I should see my changes from T2 in my diagram at T3.

By use case, here are the features I'm looking for:

1. design: intuitive interface, UML 2.0 support, export to image, forward engineering
2. understand: reverse engineer, not overly resource intensive, information hiding, dependency illumination
3. maintain: code-to-model synchronization, IDE integration

Most developers, in my experiences, only really need support for use cases 1 and 2 - they create diagrams to help them clarify or communicate design thoughts at the present time, and they capture these thoughts in some formal documentation (on a good day!). However, they typically aren't as concerned with maintaining their models. If something in the code has changed that affects the diagram, they'll just re-create (or re-reverse engineer) the diagram - they don't necessarily need the tool to keep in synch with the underlying code base. For my client, however, this wasn't going to work. They needed the code-to-model synchronization that comes with that 3rd use case. Updating documentation was a priority, and so the barriers needed to be as low as possible to do so.

So going off a few years of UML experience, a little internet research, and some conversations with friends, I narrowed my search to six tools: Poseidon, StarUML, Together for Eclipse, Omondo, Sun Java Studio, and MagicDraw. I put each of these tools through their paces, and here's what I found.

I fell in love with poseidon as soon as I opened it. First of all, there's a free version that is very capable, which is great. The interface seemed very usable, there were a bevy of nice features, and the GUI effects were very cool. But the price you pay, it seems, is performance. Even with a relatively small project (a few hundred classes), it was pretty memory intensive and slow. In the age of instant gratification, waiting a few seconds to drag-and-drop a class on a class diagram is too much. Yes, I'm impatient. Overall though, I got a good feel from poseidon. For a small college-type project, great. Not ready for prime time though, in my opinion.

Another free UML tool, and this one was fast. Opening a project, dragging and dropping, rearranging - lightning quick. It even seemed to scale a little better to larger projects. The problem was, at least for me, that the interface was a little perplexing. I think this is because they are using Irrational's, errr....I mean Rational's terms and approach - which if you're not drinking their kool-aid is very counter-intuitive. For example, you can store your diagrams in one of five model types: the Use Case Model, Analysis Model, Design Model, yada-yada. This is just confusing. The graphic components are a bit cumbersome to use as well, and I found myself spending way too much time rearranging boxes and lines. All in all though, there are some nice things about it.

Together for Eclipse
I've used past versions of Together from Borland, and I have to admit, the tool is pretty bad-ass. With this version, they went the extra-mile and integrated with Eclipse, a very laudable effort. The problem is that they don't just give you a plug-in to hook in to your Eclipse, they give you their version of Eclipse instead. What the...? Well, I don't want to have to use two different Eclipses, and I don't want to be locked in to Together's Eclipse, so I guess I'm done here...

There are two versions of Omondo available. The first is free, and pretty capable...until you realize that your model is stuck in your Eclipse. There's no image export, or even save available. Obviously this won't work, so I tried their Studio version. Bingo. This tool is very nice. First, it's plugged in to Eclipse, so round-trip engineering is all there (and so simple). The UI is intuitive, and I found some nice features for reverse-engineering (finding dependencies, associations, etc.). All that, and it's fast too. The only downside is that it adds annotations to your source - so for a legacy system where you don't want to be responsible for changing so much existing code, this might not work.

Sun Enterprise Java Studio
Admittedly, I did not dig quite as deep into Sun's product. I guess I'm settled on Eclipse (for good or bad), and I just couldn't see switching between two big-time IDEs. Overall though, and some friends confirmed this, it seems a bit buggy, slow, and confusing (especially the reverse engineering). There are some nice features...and it is free, but it wouldn't be my first pick.

I found this to be a great all-around tool. It doesn't integrate into Eclipse and it didn't seem to solve the code-to-model synchronization problems from my 3rd use case, but all else was very solid. The UI features were quite helpful. For example, in a class diagram you can click on any class and automatically add to the diagram all related types. Awesome. It's also pretty quick even with a larger project, and not too expensive to boot. I found that MagicDraw recently won a reader's choice award from JDJ, and I can see why.

Summing Up
From the feature requirements I defined at the start, here's how the tools match up:

Feature poseidon StarUML Together Omondo Sun MagicDraw
Usable Good Bad Ok Good Ok Ok
UML 2.0 Yes Yes Yes Yes Yes Yes
Image Good Good Good Ok Good Good
Reverse Eng. Good Ok Good Good Ok Good
Performance Bad Good Ok Good Bad Good
Info Hiding Good Ok Good Ok Ok Ok
Dependency Ext. Ok Bad Good Good Ok Good
Round Trip Bad Bad Good Good Bad Bad
Eclipse Integ. No No Kinda Yes No No
Price Good Good Bad Bad Good Ok

In the end, every tool that I looked at will handle use cases 1 and 2 - designing from scratch and understanding some existing code. If this is all you need, and your project small and budget tight, poseidon will do the trick. It's free, intuitive, usable, and has some "good-enough" features. If, however, you need that 3rd use case of maintaining your documentation (code-to-model synchronization), then the only two tools of the seven that'll do are Omondo and Together. Of these two, Omondo is superior if only because of the better integration with Eclipse. Finally, don't overlook MagicDraw if you need something more robust than poseidon, but less so than Together or Omondo. The price is reasonable, the tool is fast and very capable.

I am currently living in Pittsburgh, PA, working as a Senior Technical Consultant for Summa, and studying as a part-time graduate student in Philosophy at Carnegie Mellon University.

1. I've never been much of an optimizer as a consumer - I'm more of a satisficer. When I shop for cars, I don't test drive dozens in hopes of finding "the best". Does anyone? Nope, I figure out what I want out of a car, and then I search one-by-one for one that meets my needs. When I find it, I buy. Done and done. Sure, I may have overlooked the "optimal car" for me, my platonic ideal of an automobile, but instead of spending months talking to car salesmen, I'm driving my new car. That's the theory at least: it's just not rational to do an exhaustive search when an option set is so large, and even if it was, in practice, you'd just end up with more regret anyway. And so it was when recently I was asked to research UML tools for client.

I believe that software development is fundamentally about making decisions, and so this is what I write about (mostly). I'm a Distinguished Technical Consultant for Summa and have two degrees from Carnegie Mellon University, most recently one in philosophy (thesis here). I live in Pittsburgh, PA with my wife, 3 energetic boys, and dog. Subscribe here or write me at ben at summa-tech dot com.

Got a Comment?

Sign up to hear about the next post!

If you liked this article and want to hear about the next one, enter your email below. I don't spam - you'll only receive an email when there's a new post (which is about once a month, tops). It's all low-key, straight from me.

Comments (0)

 None so far!