Drowning in an expanding sea of source files?

When your collection of source files has grown beyond the ability of your developers to understand it, it's time to restructure your codebase. Current directories, packages, assemblies, etc. have evolved ad-hoc, and their interdependencies add to the complexity. The team is drowning in unorganized source files, making the addition of new features unnecessarily hard.

A well-understood file structure, with defined subsystems and interfaces, would change all this. But your product development and delivery schedules make it very hard to consider a major refactoring effort. But it is feasible to discover, define, and reap the benefits of an efficient architecture for your existing codebase, without major surgery.

Discover and define your codebase architecture, easily

Structure101 reorganizes your codebase from the outside to reduce risk and map right into the code. The process starts with a well-structured containment model for existing source files, reusing current structures where they help, and pulling together cohesive clusters of files into new containers where it makes more sense.

A set of “architecture diagrams” is created to visually express the interfaces between model containers. These diagrams map to the actual source files and can be checked at coding and build time, providing a common understanding and continuous guidance for developers.

The new architectural model is now part of your codebase, evolving deliberately with each iteration. It points out where code needs to be refactored to make it compliant, and shows how to align the physical structures with the new architecture. Control if and when these changes get implemented into your workflow. Your new architectural model guides your ongoing development, from outside the code.

Interactively organize the classes into a hierarchical, compositional model

  • Use existing structures such as packages, Maven projects, Assemblies, etc.
  • Use Structure101 suggestions to recompose based on class cohesion
  • Use complexity measures to guide remodeling

Create diagrams which express layering and visibility for the model

  • Cells in diagrams map to sets of code items
  • Relative positioning and visibility properties of cells define allowed dependencies
  • Diagrams are immediately compared to the current code base and violations indicated

Simulate refactorings to remove rule violations

  • Rearrange the contents of files and classes
  • Immediately see the impact of changes on the model
  • Create a list of refactoring actions for export to the IDE plugin

Share diagrams with the whole team

  • 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

Increase the value of a well-structured code-base:

  • Your development team has a common understanding of the architecture
  • Code edits are automatically checked for consistency
  • New developers are productive quickly
  • Reduce the impact of changes with predictability
  • Create dependable schedules
  • Enable phased release and regression testing
  • Reduce test cycles
  • Allow automatic checking of interface integrity
  • Create code reuse

Get started today

Structure101 software architecture tools are available directly from Klocwork. They can be purchased to enhance an existing Klocwork deployment or combined in a new source code analysis deployment. Contact us for more details.