When dealing with software structure, dependency analysis becomes a central topic. For nontrivial applications, it’s almost impossible to understand or even control how classes, packages and package trees interact with each other by just examining source code.
However, understanding how things depend on each other is crucial for making the right design decisions during development. We cannot expect to have a good design if we don’t know it!
What we really want is to look at our artifacts, see what they need and what needs them. Given this, we can make better decisions and will end up with a better design. Sometimes we discover the need for refactoring to improve our design. Sometimes we just want to discuss some design issues. Instead of stumbling through the code, isn’t it much better to look at a dependency graph?
Unfortunately, it’s impossible to look at everything at once. To get useful graphs, we have to carefully select the perspectives and scopes. Otherwise we’ll end up with very big and clumsy graphs. For example, we may want to look at an artifact to see how its contained artifacts interact or how the artifact itself interacts with the rest of the application.
Another issue is graph layout. Without sophisticated layout capabilities, even rather small graphs cannot be put into a picture we want to look at. At the same time, graph layout is a complex task and much effort has been put into STAN’s graph layout engine to obtain good and fast results.
STAN shows dependency graphs for all levels of abstraction. Generally, nodes denote artifacts and edges denote dependencies. An edge’s weight reflects the dependency’s strength, which is the number of underlying code dependencies. Selecting an edge will show you those dependencies.
The Composition View allows to look into the selected artifact, to see all its contained children and the dependencies between them. You may investigate dependencies between members of a class, classes of a package, packages, children of a package tree and between libraries.
STAN’s layout engine guarantees, that – as far as possible – edges point into the same direction, either top to bottom or left to right, depending on the chosen layout orientation.
Artifacts can be expanded to arbitrary depth to dive deeper into the structure.
Additionally you may navigate into any of the displayed artifacts as well as up and down the artifact hierarchy.
The Couplings View allows to look around the selected artifact, to see all its incoming and outgoing dependencies. You may investigate dependencies to and from classes, packages, package trees or libraries.
In addition to the direct dependencies one can optionally make visible intermediate dependencies between the displayed artifacts.
Here, artifacts can be split to explore how its children contribute to the shown dependencies.
The Sandbox View allows to look at dependencies between any classes, packages, package trees or libraries. Artifacts can be easily added using Drag’n Drop from the Structure Explorer.
Artifacts may be dropped into the Sandbox’s top level pane or into a node that represents an ancestor of the drop node. Dropping into a collapsed node will automatically expand the node. Higher level artifacts may be split to explore how its children contribute to the shown dependencies. Expand/Collapse is also supported.
If a graph is too large to fit in your view, the Graph Overview simplifies navigation.
- The Graph Thumbnail lets you choose the shown region visually.
- The Graph Contents allows you to reveal a particular node by selecting it from a list.