With long-lasting software systems, the maintenance costs far exceed the initial development costs. Escape the cost trap with timely, proactive modernization measures. An evolutionary approach guarantees predictable costs, continuous releases and immediate customer benefits with manageable risk.
Contents
Studies show that the success of companies is increasingly determined by software. It is therefore no coincidence that one of the most successful retailers (Amazon) is one of the most successful software companies – it has laid the foundations for its success. Particularly in the industrial environment, there has been an increasing need for software development in the course of digitalization over the last few decades, which is why many companies have established their own software development teams. Initially, however, these often consisted purely of specialist 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 was recognized and the teams were expanded to include software engineers. The long history of development, the heterogeneous teams and a corresponding fluctuation of developers lead to heterogeneity in terms of development methodology, the technologies used and code quality. If this heterogeneity is not countered by continuous consolidation, the costs of maintaining the software increase enormously over the years. In addition, changes become increasingly difficult and the integration of new functionality is only possible with a great deal of effort and risk. In the worst case, technical debt can lead to “technical bankruptcy” (see Figure 1).
Targeted modernization can greatly reduce maintenance costs and risks and allow you to react more quickly to future requirements. An incremental approach means that adjustments can be continuously incorporated into productive operation and ensures that the system always meets requirements. The cost of modernization in relation to a new development can be estimated relatively easily and accurately. Another aspect of technical applications is often that the requirements in terms of model sizes have grown considerably over the years, meaning that the runtimes for calculations and memory requirements are no longer practicable with the current implementation of the software. In the course of modernization, such bottlenecks can be identified and eliminated by an adequate software implementation using the parallelization potential of modern hardware architectures.
Figure 1: Premature end of life of software due to technical debt
The basis for a technically and economically successful modernization of legacy software is a well-considered overall strategy. It is important to approach the topic as impartially as possible and to consider and evaluate radical approaches such as completely new development or the use of standard software in addition to modernization and refurbishment. When considering whether to reengineer existing software or to plan a new development instead, the former alternative is often preferable because reverse engineering, right down to the requirements, can be extremely time-consuming (see Figure 2). Often there is almost no documentation available and the know-how is only manifested in the source code. Due to the substantially lower costs, risks and lead time, in many cases a decision will therefore be made in favour of 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 the respective measure, it must be weighed up whether the resulting benefit justifies the expense.
When modernizing, parts with a high and low need for change should be identified and strategically treated differently. For the stable parts with a low need for change, you 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, whereby a stable production system is available at all times and further modernization can be decided as required (see Figure 3). An anti-corruption layer isolates parts of an overall system and ensures compatibility between parts developed in different evolutionary ways (legacy application with new code parts, new application with legacy code parts).
An important strategy in the course of modernization is the continuous reduction of dependencies and improvement through modularization. The goal is loosely coupled components with clearly defined interfaces and, where possible, standardized data formats and protocols. In the case of highly efficient and specialized implementations in Fortran/C/C++, this enables simple integration into platforms such as Python, .NET and Java in various application scenarios.
The continuous expansion of test automation offers significant potential for improvement in the course of incremental modernization. On the one hand, this documents the behavior of the current system and, on the other hand, the tests serve as a “safety net” to automatically detect unintended side effects and errors in the course of changes.
In the course of the actual implementation of changes and extensions, there are numerous opportunities to benefit from the further development of modern programming languages and libraries and thus make the software more maintenance-friendly, robust and performant. Especially with regard to performance, there have been many improvements in recent years (parallelization, etc.) from which you often benefit directly. In addition, parts of in-house development can often be replaced because this functionality is now directly supported or corresponding open source alternatives are available. Technically demanding tasks with complex calculations can thus be solved more quickly (strong scaling) or larger problems can be solved (weak scaling).
In addition to the above-mentioned modernization at product level, entire software development processes should of course also be analysed and improved/modernized where necessary. In recent years, studies have clearly shown that the rapid changeability (including rollout) of software in particular is a good indicator – not only for the efficiency of software development, but due to the increasing importance of software, usually even for the overall economic success of a company. As a long-standing development partner for large industrial software systems, RISC-Software GmbH therefore also supports and promotes the modernization of the software development process at its partner companies.
Figure 2: Categorization of re-engineering measures
Figure 3: Step-by-step migration from the legacy to the new application with the help of Anti-Corruption Layer
The development of many large software systems began in the 1990s. At that time, there were far fewer programming languages compared to today, open source was hardly an issue across the board 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 being developed 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 yet known or widespread.
While numerous new, modern programming languages became established in the 2000s, the development of C++ seemed to stagnate. After the release of C++ 98, work began on the successor version – but its completion was delayed until 2011. To prevent another long phase of stagnation, the C++ committee changed its publication process and delivers a new standard every three years. The response to new C++ versions has been extremely positive – more and more companies are actively participating in the further development of this powerful language. RISC Software GmbH is represented on the committee by Michael Hava via the ASI(https://www.austrian-standards.at/).
The C++ committee has succeeded in significantly improving readability, robustness and performance in many areas without breaking existing code. Applications therefore benefit directly from the improvements without a lengthy/expensive rewrite and can be “ported” incrementally to Modern C++. While existing code continues to work, source code can be improved locally step by step.
Below are some examples to show what is possible in terms of compactness, expressiveness, robustness and efficiency in the context of local improvements.
The following example demonstrates potential for improvement in terms of #resource management, #readability, #robustness, #compactness
The following example demonstrates potential for improvement in terms of #compactness, #readability
The following example demonstrates potential for improvement in terms of #parallelization, #expressiveness, #compactness, #readability, #robustness
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 results/time. Their customers include Airbus, WFL, DS-Automotion and numerous others, with whom they often work in long-term development partnerships. Their range of services extends from the development of new systems and the re-engineering of existing systems to consulting and training.
The VML(https://virtual-modeling.at) is a software library from RISC Software GmbH that implements new algorithms for the exact geometric modeling of solids. It supports Constructive Solid Geometry (CSG) like operations and solid sweeping. The VML offers good scalability in terms of the number of operations performed during modeling. The library is ideally suited for industrial applications that have combined requirements in terms of 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). VML is used, for example, in the CrashGuard Studio product from WLF Millturn Technologies(https://www.wfl.at). CrashGuard Studio is a 3D simulation software for multifunctional CNC turning, drilling and milling centers, which makes it possible to simulate machines with their complex kinematics and extensive machining and expansion options very realistically.
Airbus Defence and Space uses the multidisciplinary Lagrange structural optimization system in the field of aircraft structure engineering and started its development in the early 1980s in the Fortran77 programming language. RISC Software GmbH started the re-engineering of this software system in 2005. The first step was to replace a critical calculation component in order to remove its limitation with regard to the maximum problem sizes. The new development was carried out in C++ and was integrated into the old system. In the next step, the entire system was ported from the old Fortran 77 language standard to the newer Fortran 2003/2008. As the overall system had limitations in terms of the maximum problem sizes in many places and the expandability was limited due to the design, an incremental re-engineering of the overall system was carried out in Fortran 2003/2008. The new system should also be able to be used in productive operation at any time and deliver the same results as the old system.
As part of a simulation system, the FH Wels developed a routine for calculating the elastohydrodynamic pressure that occurs in the oil film between the piston and cylinder in an internal combustion engine. RISC Software GmbH carried out consulting for optimization measures for this calculation routine implemented in C++. The aim was to make the best possible use of the potential of modern hardware architectures. By analyzing the system, the critical points were identified and suitable optimization measures were developed. Finally, the procedure and results were presented in a workshop.
Senior Software Architect
Senior Software Architect & Project Manager
Head of Unit Industrial Software Applications
