Chapter 1. Sonargraph's Next Generation - Sonargraph 9

Sonargraph 9 is built upon the experiences that hello2morrow gained during the development and support of the existing products Sonargraph 7, SotoGraph and SotoArc. Sonargraph 7 offers two product lines: Architect and Quality - both supporting Java. Both allow to explore and monitor technical quality aspects of software systems.

Sonargraph Quality adds to Sonargraph Architect history features (database approach) and analysis extensibility by user defined queries and metrics. Sonargraph Architect is more lightweight and integrates smoothly with a lot of different IDE’s, build and quality infrastructures (e.g. Eclipse, IntelliJ, Sonar, Jenkins, Ant, Maven, ...).

SotoArc and SotoGraph are different product lines supporting C/C++ and C#. These product lines have a completely different user interface and approach to explore and monitor software systems than Sonargraph 7.

Product Family

Sonargraph consists of several products that help to ensure quality throughout the software development as shown in the following image:

Sonargraph Products
Figure 1.1. Sonargraph Products


  • Sonargraph Architect allows code exploration and definition of rules, i.e. architecture, metrics, anti-patterns, thresholds, tasks, refactorings.

  • Sonargraph Developer are integrations into IDEs that provide early feedback to developers. With an Developer license it is also possible to start the Sonargraph Architect application and use its advanced visualization and exploration possibilities.

  • Sonargraph Build are integrations for various environments to run the quality checks on the continuous integration server.

  • Further plugins exist that allow the integration of Sonargraph into SonarQube and Jenkins.

    We host an Open Source project on GitHub that provides easy access to all information contained in a Sonargraph XML report and can be used for custom post-processing: https://github.com/sonargraph/sonargraph-integration-access

The Benefits of Sonargraph 9

Single Lightweight Platform and a Coherent Product Stack

All product lines will be replaced by one platform for statically analyzing software systems. The platform will combine the most critical features of the different existing product lines while offering one look and feel with a modern user interface and integration with all commonly used tools and platforms as before.

The most basic product will be the Sonargraph Explorer, offering all needed exploration and navigation features and metrics to enable the user to analyze a software system fast and thoroughly.

Sonargraph Architect will add to this a flexible way to define different architecture aspects and validate them on the fly. On top of that, products for adding history/comparison support to monitor multiple systems at once are to come.

Multiple Language Support

Sonargraph 8 supports different languages depending only on the license without the need to have different installations. There is a unified approach (i.e. one user interface) to explore and monitor systems implemented in different languages. Systems have a module structure where each module can have a different language.

Inter-module dependencies with different languages are detected where possible (e.g. by analyzing JNI calls). A generic component approach is used for all supported languages - currently Java, C#, C/C++.

Greater Parser Model Detail, Less Memory Consumption and Virtual Models

Nesting of programming elements is correctly reflected in the model. Dependencies are tracked down to method and field level offering more detailed exploration. Sonargraph 8 has little memory consumption, as only the model coming from the different parsers is held in memory and all ‘derived’ structural elements (e.g. a layer) and their dependencies are calculated on demand. You can create multiple so-called virtual models. A virtual model is a space where the model from the parser(s) can be modified by refactorings and detected issues can be transformed into tasks or ignored. This allows the simulation of different approaches to change a given structure with different issue resolutions.

Snapshots

The complete model of a system is stored in a compact binary format. This enables fast startup times (the last snapshot is used if available) without having to perform a full re-parse. Furthermore complete systems might be compared and historically analyzed - even passed around to enable reviews based on them - by directly loading the snapshot.

Analyzers taking advantage of Multi-Processor Hardware

Analyzers calculate metrics and analyze dependency structures (e.g. cycles) and content of source files (e.g. duplicated code). These analyzers run in parallel in a multi-threaded environment providing more speed while not blocking user interaction. Once a analyzer has finished, it`s results are available to the user.

Extendable Analysis via Groovy Scripts

The user can extend the platforms functionality by writing Groovy scripts accessing the model created by Sonargraph 9 . These scripts can either simply act as custom queries finding artifacts with specific characteristics and/or to create issues pointing to potential problems in the system or create additional metrics.

Architecture DSL

Sonargraph 9 uses a DSL (domain specific language) approach to describe the architecture. A system's architecture can consist of multiple architecture aspects which are checked in parallel.

Flexible Exploration of Dependency Structures

You are free to decide how to explore dependencies. Sonargraph 9 offers a tree-like explorer, a graph viewer and a simple table based viewer.

Automated Updates and Flexible User Interface

Automated updates and a flexible user interface (layout and customization) are provided as Sonargraph 9 is built upon the Eclipse Rich Client Platform (RCP). Sonargraph Build plugins for Maven and Gradle can also be configured to update automatically.

Exchangeable Quality Artifacts

The software system analysis comes with a multiple file approach. The software system is comprised of a main software system file, analyzer configurations, user defined scripts, different architecture aspects and so forth. The approach makes it easy to share valuable aspects of the analysis between software systems as well as to centralize common aspects in bigger companies.