Improve the organization of your software architecture

If your codebase is not organized, you are incurring unnecessary cost and frustrating those involved in the development process.

Steps to improved modularity

1

Interactively organize the classes into a hierarchical, compositional model

Use existing structures such as packages, Maven projects, Assemblies, etc.

Use Structure101’s suggestions to construct a composition based on class cohesion

Use over-complexity measures to guide remodeling

2

Create diagrams which express layering and visibility for the model

Cells in diagrams map to specific code items

Diagrams are immediately compared to the current code base and violations indicated

3

Simulate refactorings to remove rule violations

Immediately see the impact of changes on the model

Create a list of refactoring actions for export to the IDE plugin

4

Share diagrams with the developers

The whole team sees the architecture within their IDE

Warnings as soon as code changes violate layering and visibility rules

Break the build to ensure rules are enforced

5

Align the physical code base structure with the model structure when you’re ready

Use packages, namespaces, jars, assemblies, filesystem, OSGi bundles etc.

Push architecture into the physical code-base structure

How it all fits together

Structure101 empowers you to improve your architecture while integrating seamlessly with your existing workflow, regardless of what tools you use for development, build and testing.

With specific integrations for ...

Structure101 ADE
& IDE plugin

Using the Structure101 Architecture Development Environment (ADE)1, architects manipulate the model (the Levelized Structure Map), to determine what concrete actions should be taken to better organize the code. Structure101 models are derived directly from the code 2.

The architects' work is captured in the form of Architecture Diagrams (rules)3a and Action Lists3b (recommended changes).

Developers who use Eclipse, Visual Studio or IntelliJ receive the architecture diagrams and action lists right inside their IDE4. Architecture diagrams guide conformance, while violations are highlighted on the diagrams, and raise edit-time warnings. A mouse click takes the developer direct to the source of a violation.

In the case of an existing codebase, the plugin can be configured to highlight only new violations so that developers are not overwhelmed by warnings, yet can ensure that the architecture never deteriorates further.

Actions designed by the architect to improve the overall organization of the codebase, are presented and can be implemented en masse, or over time, and at a pace that suits the team's release schedule.


Structure101 Build & Continuous Integration

Structure101 Build5 comprises a simple but powerful set of command line utilities, that integrates easily with almost any continuous integration environment, including off-the-shelf integration with Hudson/Jenkins, Maven and Sonar.

  • Break the build on violations to the defined architecture
  • Break the build on exceeding user defined structural thresholds
    • Referred to affectionately as the KALOI principle ('Keep A Lid On It').
    • Based on Structure101's powerful but simple ('XS') measurement framework
    • No matter how bad (or good) things are with your codebase, make sure it doesn't degrade over time.
    • Better still actively use the KALOI principle to gradually improve your codebase as you move from one iteration to the next.
  • Automatically create customizable, detailed or summary reports
    • with data on the size, composition, structure, complexity and architectural integrity of each build.

Structure101 Repository

The Structure101 Repository is a light-weight, low maintenance, file-based XML data-store repository. It can be accessed locally, or remotely (once the Structure101 Web Application has been installed). It stores the target architecture, action-lists and all architecture related data for each published snapshot of your build.

Structure101 Webapp

The Structure101 Web Application6 web-enables a Structure101 repository, providing high-level trending and cross-project reports on the status and integrity of your software architecture.

Information available includes:

  • Architecture diagrams
  • Dependency matrices
  • New dependencies and violations
  • Size and over-complexity stats
  • Summary reports

Information available only through the web application:

  • Cross-project size, complexity and violation charts
  • Size, complexity and violation trends
  • Dependencies and violations that have been removed

As well as making the information available in a web browser, the web application supports RSS feeds that notify of changes in your software architecture.

Tools

Structure101 puts a whole array of tools at your disposal as you work towards improving the modularity of your codebase.

Reorganizing

Discover & define an acyclic architecture

With Structure101 you can reorganize an existing, monolithic, unstructured code-base into one with the essential properties of modularity.

Back in the 90's John Lakos wrote one of the defining software engineering texts, Large-scale C++ Software Design, which introduced the concept and importance of levelization in software development.

Levelization is the key concept behind the Structure101 "model" of your code, the Levelized Structure Map (or 'LSM').

With a rich set of viewing and filtering options, tune the LSM for the specific task at hand. Then manipulate the model using drag 'n' drop, optimizing the organization of your code into acyclic, "mind-sized chunks" throughout.

Visualization

Understand

In order to discover your architecture you need to first understand it.

From directed graphs to dependency structure matrices ('dsm'), architecture diagrams, the levelized structure map ('lsm'), and rich, smart filtering, Structure101 provides you all necessary visualization tools to optimize your codebase into “mind sized chunks” throughout.

Measurement

Focus

Structure101’s simplified measurement framework guides your development of a well-structured architecture, without losing you in a sea of numbers.

Comparison

Pinpoint differences

Structure101 supports the ability to compare snapshots so you only need to review architectural changes and not the whole code base after each new build.

Dependency management

By xkcd

The heart of software development

Understanding and managing dependencies is at the heart of software development and is central to good decision-making.

Even in the largest, most complex codebases, Structure101 not only provides powerful tools to understand dependencies, it suggests how they can be better organized.

Impact analysis

Evaluate before you change

Structure101 provides complete impact analysis as a list and graph, so you understand the risk and test effort associated with making changes, or the effort involved in isolating items for reuse.

Architecture

Diagrams & rules

Define your desired architecture with Structure101’s semantically rich, intuitive, layered block architecture diagrams, present it to your developers through our IDE plugin and enforce it by integrating into your build.

Communication

All on the same page

Architecture is communicated to the development team through the IDE, showing errors or warnings on violations.

Ongoing trends and cross project monitoring are available to the whole team via the Structure101 Web Application and Sonar plugin.

Build

Don't do it!

With support for Ant, Hudson, Jenkins, Maven, MS Build etc Structure101 integrates into your build to ensure the team stick to the defined architecture.

Scalability

Works for the largest codebases

We know, scalability is not a "tool", but it is worth mentioning. Organizing an entire codebase requires tools that are performant even when working with the very largest codebases. We’ve run Structure101 against 16,000,000 lines of code, our customers use it on more.

Continue the tour...

process

workflow & integrations

tools

screenshots