One of the goals behind UML is to help stamp out ambiguity in specifications and designs. This is a good and noble goal, but UML is nobbled by its own nobility.

Booch, Rumbaugh and Jacobson, who donned matching aprons and cooked up UML, baked in some pretty subtle constructs to distinguish between even subtler concepts that - in theory - let you produce precise, unambiguous models. As you'd imagine, this has led to some fraught debates over the interpretation of these subtle modeling elements.

Last time, I delved into the equally fraught debate on whether program methods should have single or multiple return points, and - as many readers correctly noted - the answer is: "Who cares? Clearer code and getting the job done are much more important."

And so it is with UML. All too often I've seen analysts and developers get bogged down in unnecessary details: an ailment generally known as analysis paralysis. This is not to disparage UML itself: it's perfectly fine for the job at hand. But whatever you're using it for, it's a means to an end, not the end goal.

What follows are some answers to the more common questions that bog people down, offered in the hope these will save you from some serious hours stapled to a whiteboard in the company meeting room.

Q: These use cases seem related - we should connect them. Shall we use <<includes>> or <<extends>> stereotypes?
A: Don't worry about it. These are use cases, not code.

Q: These domain classes are related - we should join them up. Shall it be an aggregation, composition or association type of pointy line?
A: Except in the most rare of cases, it doesn't matter. It probably won't affect the code. To illustrate, here's an aggregation relationship in Java:

private Planet myPlanet;

And here's an association in Java:

private Planet myPlanet;

Spot the difference?

Composition is a bit trickier, as the container class is responsible for the contained class's lifecycle. Simplifying things a bit, it'll look something like this:

private Planet myPlanet = new GasGiant("Jupiter");

But if you're looking at a domain model and not the detailed design, it definitely doesn't matter. The type of relationship is only relevant much later on, and by then the one to choose should be obvious.

Q: Which direction should the arrows go in on my robustness diagram?
A: Again, don't worry about it. Showing the direction isn't the purpose of the diagram. Just draw lines without arrowheads, you'll save time and not lose any relevant detail.

Q: How do I get my diagramming tool to split up the "focus of control" rectangles on my sequence diagram?
A: Guess what? Don't worry about it. Sequence diagrams were originally intended as a tool for allocating behavior among collaborating objects, and it's what they're best used for. So being able to visualize the start and end of individual methods is less important than identifying the methods in the first place. Plus, messing about with those little rectangles can get really fiddly. It's better just to switch them off altogether.

That's all fine as far as it goes, but how do you know when a particular nuance is inconsequential and when it's an important item to specify? That's for next time, when I'll describe some handy ways of spotting the subtle, and not-so-subtle, symptoms of analysis paralysis on your project.®

Matt Stephens has co-authored Use Case Driven Object Modeling with UML: Theory and Practice, which illustrates how to step nimbly from use cases to code while avoiding the dreaded analysis paralysis.

More comments…

Related stories

Read, test, don't repeat - how to avoid code complexity (5 May 2008)
Hafta Man and the threat to agile design (30 April 2008)
Comment judiciously, refactor if needed, avoid the 'f' word (28 March 2008)
Extreme Programming in risky position, says co-creator (13 March 2008)
SOA benefits: too much reuse of reuse? (8 March 2008)
Time for UML tools to evolve (29 February 2008)
Agile lands role in games and business software (28 February 2008)
UML officially an unfunny matter (20 February 2008)
Tools vendors stuck on UML and agility (13 February 2008)
Penguin-powered UML modeling (29 January 2008)
Dip into concept programming (16 January 2008)
Telltale signs your model is stuck (3 January 2008)
Sequence diagramming that's fit for purpose (22 December 2007)
Bloody code! (4 December 2007)
So many paths to Nirvana (28 November 2007)
Model use cases that work (23 November 2007)
The ICONIX Process in pieces: Domain modelling (13 November 2007)
A simple unit test for GUIs (12 November 2007)
Don't unit test GUIs (22 October 2007)
Why UML won't save your project (8 October 2007)
Use case driven object modelling with UML: Theory and practice (29 March 2007)