Software modernisation

A complete rewrite may seem sensible in certain cases, especially if the existing system is extremely outdated or unmaintainable. However, a rewrite involves considerable risks and challenges. An existing system often contains years of accumulated requirements, workarounds and business logic that can be lost in a complete rewrite. This can lead to unexpected problems and a strategic disaster, as described in “Things You Should Never Do, Part I – Joel on Software”.

Instead, incremental software modernisation offers several benefits:

• Risk minimisation: incremental improvements keep the system functional during the modernisation process, reducing the risk of downtime.
• Cost control: Modernisation can be more cost-effective because it focuses on improving specific areas rather than redeveloping the entire system.
• Knowledge retention: Existing business logic and accumulated requirements are retained, reducing the likelihood of errors and gaps in the new system.
• Flexibility: Modernisation allows new technologies and architectures to be introduced gradually, enabling better adaptation to changing business requirements.

Overall, modernisation is often the more pragmatic and safer choice to future-proof a system without incurring the risks and costs of a complete rewrite.

Software modernisation is necessary to maintain competitiveness, minimize security risks and improve maintainability. Outdated systems can have security vulnerabilities and are often difficult to expand. The use of modern technologies such as microservices, containerisation (e.g. Docker, Kubernetes) and cloud computing (e.g. AWS, Azure) can increase the flexibility and scalability of software.

The first step is a comprehensive analysis of the existing system. This includes an architecture review, a code quality assessment and the identification of obsolete technologies. Tools such as SonarQube can be used to analyze the code, while architecture review workshops help to understand the structure of the system.

The choice of technologies depends on the specific requirements, but common options include

• Programming languages and frameworks: switching from older versions (e.g. Java 8) to newer ones (e.g. Java 17).
• Containerisation: Use of Docker for better portability.
• Cloud services: Use of native cloud solutions for reduced downtime and greater resilience.

Code quality can be improved through the introduction of automated tests, code review processes and the application of design principles such as SOLID and DRY. Tools such as Jenkins or GitLab CI/CD can be used to automate tests and deployments.

A rewrite means developing the entire system from scratch, while refactoring improves existing code structures without changing the functionality. Refactoring is often less risky and more cost-effective, as it retains the existing logic and the collected requirements.

Security can be improved by training developers in secure software development practices and their implementation, such as regular security scans and the introduction of DevSecOps practices.

Continuity can be ensured by setting up a robust testing and monitoring framework. Tools such as Prometheus for monitoring and Grafana for visualisation help to monitor the system status in real time. Automated tests ensure that changes do not have any undesirable effects.

Documentation is crucial in order to make architectural decisions comprehensible and to facilitate knowledge transfer. Up-to-date and precise documentation helps new team members to familiarise themselves quickly and supports the long-term maintainability of the system.

To prevent a modernized system from quickly becoming obsolete, continuous improvement processes should be established. These include:

• Regular updates: technologies and libraries used are updated to the latest version.
• Agile practices:  Agile methods such as Scrum or Kanban are implemented in order to be able to react flexibly to changes.
• DevOps culture: A DevOps mentality is actively promoted to improve collaboration between development and operations and to support continuous integration and deployment (CI/CD).
• Technical debt:  Technical debt is regularly recorded, prioritised and systematically reduced.
• Architecture retrospectives: Regular architecture retrospectives will be conducted to review and adapt the system architecture.
• Quality assurance: Robust quality assurance processes, including automated tests and code reviews, are established to ensure long-term code quality.

Improving the architecture during modernisation is crucial. Here are some approaches that can help:

• Modularisation: the system is divided into smaller, independent modules, which reduces complexity, and increases flexibility. Each module can be updated and maintained separately. For example, modules can be identified by applying tactical domain driven design, e.g. aggregates and sub-domains.
• Strategic Domain Driven Design (DDD): DDD organizes the architecture around the business domain by identifying bounded contexts and defining clear interfaces. This makes it easier to adapt to business requirements and promotes a clear separation of responsibilities.
• Strangler Fig Pattern: This pattern enables step-by-step modernisation by developing and integrating new functions as separate components. Old system parts are gradually replaced, allowing the existing system to remain functional during the process.

By combining these approaches, the architecture of a system can be significantly improved during modernization, resulting in a more robust, adaptable and future-proof software solution.