Skip to content

Software Modernisation

Incremental re-engineering for sustainable software development

by Michael Hava, MSc, DI (FH) Josef Jank, MSc, and DI (FH) Alexander Leutgeb

For long-lasting software systems, maintenance costs far exceed initial development costs. Escape the cost trap through timely proactive modernization measures. An evolutionary approach guarantees predictable costs, continuous releases and immediate customer benefits with manageable risk.

Table of contents

  • Get out of (technical) debt
  • The ideal approach depends on the problem
  • Benefit from the potential of modern C++
  • We have already achieved a lot for our customers
  • Authors

Get out of (technical) debt

Research shows that the success of companies is increasingly determined by software. One of the most successful retailers (Amazon) is therefore not one of the most successful software companies by chance, but has thus created the basis for success. Particularly in the industrial environment, increasing demand has arisen in the area of software development in the course of digitalization over the last few decades. Many companies have therefore established their own software development teams. Initially, however, these teams often consisted purely of domain experts without in-depth software development expertise. As software development increasingly emerged as a core topic, the need for software development as an independent discipline suddenly was recognized and the teams were expanded to include software engineers. The long development history, heterogeneous teams and a corresponding developer turnover lead to heterogeneity in terms of development methodology, technologies used and code quality. If this heterogeneity is not countered by ongoing consolidation, the cost of maintaining the software increases enormously over the years. In addition, changes are increasingly difficult and the integration of new functionality is only possible with great effort and risk. In the worst case, technical debt can be a result in “technical bankruptcy” (see Figure 4).

Targeted modernization can greatly reduce the cost and risk of maintenance and enable a faster response to future requirements. An incremental approach means that the adjustments can be continuously transferred to productive operation and it will be ensured that the system always meets the requirements. At the same time, the effort required for modernization in relation to a new development can be estimated relatively easily and accurately. Another aspect of technical applications is that the requirements in terms of model sizes have grown considerably over the years, so that the term for calculations and the memory requirements are no longer practicable with the current implementation of the software. In the course of a modernization, such bottlenecks can be identified and eliminated by an adequate software implementation exploiting the parallelization potential of modern hardware architectures.

Premature end of life of software due to technical debt

Figure 1: Premature end of life of software due to technical debt

Finding solution

The ideal approach depends on the problem

The basis for a technically and economically successful modernization of legacy software is a well-considered overall strategy. It is important to approach the subject with as little bias as possible and, in addition to modernization and refurbishment, to consider and evaluate radical approaches such as completely new development or the use of standard software. When considering whether to reengineer existing software or to project a new development instead, the former alternative is often preferable because reverse engineering right down to the requirements can be enormously time-consuming (see Figure 5). Many times, almost no documentation is available and the know-how is only manifested in the source code. Due to the substantially lower costs, risks and lead times, in many cases one will therefore opt for a specific modernization, where the necessary re-engineering measures (re-code, re-design, re-specify, re-think) are specifically identified for the different parts of the system. When selecting a respective measure, it must be considered whether the resulting benefit justifies the effort.

During modernization, parts with a high and low need for change should be identified and strategically treated differently. For stable parts with a low need for change, someone should always critically question whether the effort and risk justify the potentially low benefit. Anti-corruption layers offer the possibility of a step-by-step migration from the legacy to the new system, with a stable production system available at all times and further modernization can be decided as required. An anti-corruption layer isolates parts from an overall system and ensures compatibility between differently evolutionary developed parts (legacy application with new code parts, new application with legacy code parts).

An important strategy in the course of modernization is continuous reduction of dependencies and improvement through modularization. The goal is loosely coupled components with clearly defined interfaces and, if possible, standardized data formats and protocols. In the case of highly efficient and specialized implementations in Fortran/C/C++, this enables easy integration into platforms such as Python, .NET and Java in different application scenarios.

A significant potential for improvement in the course of incremental modernization is offered by the continuous expansion of test automation. On the one hand, this documents the behavior of the current system, and on the other hand, the tests represent a “safety net” to automatically detect unintended side effects and errors in the course of changes.

In the course of the concrete implementation of changes and extensions, there are numerous opportunities to profit from the development of modern programming languages and libraries and with that making the software more maintenance-friendly, more robust and better performing. Particularly with regard to the performance there were many improvements (parallelization, etc.) in the last years from which one profits immediately. In addition, parts of the in-house development can often be replaced because this corresponding functionality is directly supported in the meantime or corresponding open source alternatives are available. Technically demanding tasks with complex calculations can be solved faster (strong scaling) or larger problems can be solved (weak scaling).

In addition to the aforementioned modernization at product levels, the entire software development process should be analyzed and, if necessary, improved or modernized, too. In recent years, studies have clearly shown that in particular the rapid changeability (incl. rollout) of software is a good indicator – not only for the performance of software development, but due to the increasing importance of software usually even for the overall economic success of a company. RISC Software GmbH has been a development partner in large industrial software systems for many years and therefore also supports and pushes the modernization of the software development process at its partner companies.

Categorisation of re-engineering measures

Figure 2: Categorization of re-engineering measures

Gradual migration from the legacy to the new application with the help of the Anti-Corruption Layer

Figure 3: Gradual migration from the legacy to the new application with the help of the Anti-Corruption Layer

Benefit from the potential of modern C++

The development of many large software systems started in the 90s. At that time, there were fewer programming languages compared to today, OpenSource was still hardly an issue and the number of available libraries was manageable. C++ was the programming language of choice for demanding modern (industrial) applications. At that time, the first C++ standard was still a work in progress and existing implementations were fragmented. Standard functionality such as containers were developed individually according to different design philosophies, because modern alternatives such as STL were not known or widespread by then.

While numerous new, modern programming languages established themselves in the 2000s, the development of C++ seemed to stagnate. After the release of C++ 98 the work on the follow-up version did begin – but completion was delayed until 2011. To prevent another long period of stagnation, the C++ committee changed its release process and delivers a new standard every three years. The response to new C++ versions is extremely positive – more and more companies are participating in the development of this powerful language. RISC Software GmbH is represented on the committee by Michael Hava via the ASI (

The C++ committee has succeeded in improving readability, robustness and performance in wide areas without breaking any existing code. Applications therefore benefit immediately from the improvements without a lengthy/expensive rewrite and can be incrementally “ported” to modern C++. While the existing code still works, it offers the possibility to incrementally improve source code locally.

Below are some examples to show what is possible in the context of local improvements in terms of compactness, expressiveness, robustness and efficiency.

Resource Management (RAII)

The following example demonstrates potential for improvement in terms of #resource management, #readability, #robustness, #compactness

Resource management


The following example demonstrates potential for improvement in terms of #compactness, #readability



The following example demonstrates potential for improvement in terms of #parallelism, #expressiveness, #compactness, #readability, #robustness


We have already achieved a lot for our customers

RISC Software GmbH has many years of experience in the development of native software systems in technical applications. These are often very complex and have high requirements in terms of robustness, reliability and determinism of the results or time. Its customers include Airbus, WFL, DS-Automotion and numerous others, with whom it often has long-standing development partnerships. The range of services extends from the development of new systems and the re-engineering of existing systems to consulting and training.

Development of the software library VML (Virtual Modeling Library)

The VML ( is a software library from RISC Software GmbH that implements new algorithms for the exact geometric modeling of solids. It supports operations similar to Constructive Solid Geometry (CSG) and the envelope volume calculation. The VML offers good scalability in terms of the number of operations performed during modeling. The library is best suited for industrial applications that have combined requirements for geometric accuracy, speed and scalability. To ensure high efficiency, the VML is implemented in C++ and uses parallel algorithms that exploit the potential of modern hardware architectures such as multi-core central processing units (CPUs) and graphic processing units (GPUs). The VML is used, for example, in the product CrashGuard Studio from the company WLF Millturn Technologies ( CrashGuard Studio is a 3D simulation software for multifunctional CNC turning, drilling and milling centers, which enables machines with their complex kinematics and extensive machining and expansion options to be simulated very realistically.

Re-Engineering of the Lagrange structural optimization system

Airbus Defence and Space uses the multidisciplinary structural optimization system Lagrange in the field of aircraft structure engineering, starting its development in the early 1980s in the Fortran77 programming language. RISC Software GmbH started the re-engineering of this software system in the year 2005. The first step was to replace a critical calculation component in order to remove its limitation with respect to the maximum problem sizes. The new development was done in C++ and was integrated into the old system. In a next step the entire system was ported from the old Fortran 77 language standard to the newer Fortran 2003/2008. Since the overall system had limitations in many places with regard to the maximum problem sizes and the expandability was limited due to the design, an incremental re-engineering of the overall system in Fortran 2003/2008 was done. The new system should also be able to be used in production operation at any time and deliver the same results as the old system.

Consulting for optimization measures of a lubricant film calculation routine

The FH Wels developed a routine for the calculation of the elastohydrodynamic pressure, which occurs in the oil film between piston and cylinder in an internal combustion engine, within the framework of a simulation system. RISC Software GmbH conducted a consulting for optimization measures of this calculation routine implemented in C++. The aim was to make the best possible use of the potential offered by modern hardware architectures. Through an analysis of the system, the critical points were identified and suitable optimization measures were developed. Finally, the approach and the results were communicated in a workshop.


Michael Hava, MSc

Senior Software Architect

DI (FH) Josef Jank, MSc

Senior Software Architect & Project Manager

DI (FH) Alexander Leutgeb

Head of Unit Industrial Software Applications