Companion Products for IntelliJ^® IDEA

Analyze structure

The first step to controlling something is to understand it. Structure101 creates a model of your code in seconds, and then lets you browse and analyze its structure in different ways. Here are some applications of Structure101's structural analysis capabilities:

• Dependency management. See the dependencies within your code-base at any level, such as: method to method, function to type, class to class, package to class, directory to directory, jar to jar, etc.
• Dependency analysis. For any dependency, at any level of composition, discover the dependency's source with the click of the mouse.
• Impact analysis. Find out the impact of making a code-change, replacing a library, etc., before the team changes a single line of code.
• Understanding unstructured code. Even where the code-base has become overly complex and unstructured, Structure101 gives you ways to cut through the raw structural data and make sense of it all. For example, auto-partitioning isolates tangled items and natural clusters and dependency matrices make large graphs more readable.
• Deep structural analysis. Structure101 lets you view your code organized into different hierarchies (e.g. by package or by jar). It also lets you take slices through the whole code-base at different levels (e.g. class, package or design). "Tagging" lets you see how items in one hierarchy or slice map to other hierarchies or slices.
• Appling structural transformations. Use simple mapping expressions to transform the model hierarchy. For example, isolate test code, combine API and implementation packages, etc.

Limit structural complexity

Structure101 lets you define complexity limits at any level of decomposition (design, package, class and method). It can then take you directly to specific violations, as well as giving you an overview of how violations are distributed across the code-base.

• Find and analyze design tangles. A navigable list takes you directly to design tangles, and graphs indicate the "minimum feedback set".
• Measure excessive structural complexity. A simple framework measures the degree to which structure at any level exceeds complexity thresholds.
• Summary reports. A report gives a quick indication of the size and complexity of your code-base, and the areas of highest over-complexity.

Removing and avoiding excessive structural complexity will make your code-base easier to develop, modify, extend, test, reuse, deploy, etc.

Define architecture

Structure101 bridges the gap between the way your code-base is structured and how it should be structured, and helps your team evolve the code in line with the intended architecture.

The Structure101 graphical notation for software architecture diagrams uses an arrangement of cells to convey a number of architectural rules in a highly condensed format:

• Composition is indicated by one or more cells being contained within a parent cell.
• Layering is indicated by the top-down arrangement of cells. Cells should only be used by cells in higher layers (unless specifically allowed or disallowed by a layering override, e.g. the green arrow in the example).
• Mapping of each cell in the architecture diagram to physical items in the code-base is specified by 0, 1 or more wildcard expressions.
• Violations of the layering, i.e. dependencies in the mapped physical code-base that break the specified layering, are shown on the diagram (conformant dependencies are not shown).
• Define and edit architectural diagrams within Structure101.
• Publish architectural diagrams to a Structure101 repository so they can be immediately communicated to the team via the Structure101 web application and IDA plug-in components. Additionally, the programming team will get immediate warnings if they create any new architecture violations.

Structure101 can automatically create architecture diagrams from the current code-base structure, and/or you can create diagrams from scratch and map cells to existing code. You can edit or extend diagrams to reflect how you feel the code should be layered, now or as planned after the next iteration.

Track structural change

You can save snapshots of structural data and architecture diagrams in a Structure101 repository. This lets you compare and track size, complexity and architecture violations across multiple projects and over time.

• The ability to compare the current structure against a reference structure in the repository means that you can avoid being bombarded with problems you already know about.
• By highlighting any structural changes in the current build, Structure101 allows you to quickly focus on what really matters and drastically reduces the effort required to keep your project structure under control.
• Structure101 color-codes new dependencies in every viewer. You can quickly check if any of these are undesirable so that they can be backed out of the mainline before they become entrenched.
• The Structure101 web application includes information about all new and removed package dependencies and new and removed architecture violations. It also provides RSS feeds that can inform you about selected types of changes (e.g.  new architecture violations) so that you do not need to switch attention to the code-base structure unless and until it is required. Additionally, the web-application can show trends on the size, excess complexity (XS) and architectural violations over time.
• The Structure101 IDE plug-in can be configured to warn (or give an error) on new dependencies that violate the architecture. This helps programmers avoid making things worse, but without being swamped with warnings about prior violations. In fact, in order to avoid creating new violations, developers will often need to refactor out existing violations.

Measuring and tracking makes the management and control of architecture and structural complexity surprisingly straightforward.