How to avoid the model quagmire
Part one: Analysis paralysis
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.