Axivion Architecture Verification

Do the implementation of your system
and its software architecture match?

Only if software architecture and design are in sync with your code you are sure that you can use the software architecture as a guide and guideline for discussing the impact of new features. That is exactly what software architecture is meant for: for the long-term targeted and planned development of your products. But it is only through an automated architecture check with Axivion Suite that the necessary conformance between architecture and implementation is really guaranteed.

Software architecture conformance checks are key to success in the long run

The use of architecture checking (also called architecture check, architecture verification, architecture compliance check, or architecture conformance check) ensures that developers and software architects do not leave the basis of the system to be developed, but build on it. The structure of the system remains clear and clean, software architecture erosion and architecture debt are made transparent and thus effectively combated.

In addition, the software architecture in safety-relevant systems itself contains safety-relevant attributes and structures and must therefore be implemented precisely in the code. Deviations from the architecture become a threat to functional safety. The software architecture conformance check effectively mitigates this threat.

Where does the architecture come from?

The architecture verification is based on the structural model of the architecture and/or design of your software. This static structure can be represented as a UML model (e.g. as a package or component diagram) or as any other form of graph structure. Thus, a textual architecture description, a sketch of the architecture, or even just the knowledge in the heads of the developers involved are also suitable starting points. The procedure for this is described below.

Axivion Suite can import software architectures from widely used UML tools such as Enterprise Architect and IBM Rational Rhapsody®. This makes it possible to link the architecture review directly and easily with the existing architecture and design processes.

For those who do not yet possess architecture documentation, Axivion Suite has options for software architecture recovery, architecture reverse engineering and architecture modelling.

Depending on the initial requirements, software architecture analysis starts with an existing semi-formal model, a documented description of the architecture or by assumptions and hypotheses about a possible architecture. This classification can be roughly described by software architecture verification, software architecture recovery and software architecture archaeology.

There are intermediate states and the goal is always to create the prerequisites for continuous software architecture verification.

Software Architecture Verification / Software Architecture Check

The Architecture Check uses an architectural description in the form of a semi-formal notation, such as provided by UML. Axivion Suite can import models and mapping information from widely used UML tools such as Enterprise Architect and IBM Rational Rhapsody® as well as from other sources e.g. AUTOSAR arxml files. In this process, the mapping information describes how the architecture can be brought into congruence with the code.

After the import, the graph of the model can be immediately compared with the graph of the implementation resulting from the code analysis of Axivion Suite. As a result, convergences occur when the model and the implementation match. With surplus relations, not implemented in the implementation in the model, absences result. Finally, in the case of superfluous relationships in the implementation, divergences occur, which then indicate problems in the code.

In an iterative process, implementation and architecture can now be brought into alignment. The architecture review must become an integral part of the CI process so that no backsliding occurs. Architecture violations that arise are thus immediately uncovered and can be discussed and resolved at an early stage. Compliance with the specified architecture in the code is thus ensured, further architecture erosion is stopped and architecture debts can be remedied via targeted refactoring measures that can be directly monitored via the results of the architecture check.

+ Download our free online seminar: “Checking Enterprise Architecture models against code”

Software Architecture

Architecture recovery starts in a known project. At the beginning of the project there may have been architecture notations that were not maintained. New requirements and maintenance tasks have watered down this original architecture and it was also not maintained consistently.

Nevertheless, an idea of a basic architecture still exists and rudimentary fragments thereof are still available. The architecture hypothesis is now derived from these fragments and assumptions. The hypothesis is validated by comparison with the implementation and deviations are eliminated in an iterative process. Technically, the iterative process is based on the architecture checker of the Axivion Suite.

The Axivion Suite editor can be used in a lightweight way to create architecture sketches, which can then be mapped directly and interactively to the implementation, subsequently tested, and then adapted from the insights gained. These steps can be repeated until the intended architecture has been worked out as the basis for further development.

At the end, a validated architecture is available again, which enables the process of continuous architecture verification and architecture conformance checking to begin.

+ Download our free online seminar: „Software Architecture Recovery with Axivion Suite“

Software Architecture Archaeology

If you take over a project from another department or from a customer, the initial situation in architecture issues is usually far from a validated architecture.

Often the documentation is insufficient or incomprehensible and all you can do is make assumptions about a possible architecture. In principle, the approach is similar to that of architecture recovery, but in an extreme form.

The first hypothesis chosen should be as simple as possible in order to identify the large structures and also to hazard some guesses. This process can be supported by analysing the current state. The Axivion Suite shows you the actual state of your system structure, here you may already be able to recognise first patterns.

In any case, it is worth learning as much as possible about the software structure and intention in advance, so you can propose meaningful initial hypotheses. The architecture analysis of the Axivion Suite will support you here.

The Axivion Suite is a real game changer. Thanks to continuous tests, the programmers go through a learning curve, which increases acceptance of the respective architectural requirements. In this kind of software archaeology project, this clears the way for reaching Level 3 of the Automotive SPICE standard.

Kosmas Kopmeier
Director Engineering Consulting, SynSpace Group GmbH

Success Stories

A selection of Success Stories about architecture analysis

I would like to know more about Architecture Analysis:

    If you are already using the Axivion Suite and have a technical question, you can contact support[at] directly.