Rethinking Software Modernization

In the ever-evolving landscape of enterprise software, organizations often find themselves trapped between aging systems and the daunting prospect of modernization. However, a remarkable new approach is challenging conventional wisdom about software renewal, demonstrating how systems can be modernized without getting trapped in analyzing complex source code bases in legacy technologies or in collecting business logic from analysts and users.

This innovative technique, called the “mimicry method,” allows for the complete renewal of software systems by observing their behavior rather than studying their code. It works by analyzing the running application’s inputs and outputs, using these observations to reconstruct the underlying business logic with remarkable precision.

A Real-World Proof of Concept

To demonstrate the viability of this approach, consider a recent project where Inacta’s (https://inacta.ch) Java-based crypto-payment server application inapay was replaced with a new implementation in Go. What makes this case study particularly fascinating is that the new system maintains bit-level compatibility with all surrounding systems while delivering improved performance metrics.

Figure 1: mimicry method: Original inapay application on the left, replacement application on the right, leaving business logic, interfaces, and connected systems in place

The results speak for themselves:

• The new application is truly plug-compatible with the original system - one day, we simply removed the old application and inserted the new one, with business continuing uninterrupted and users unaware that anything had changed
• The new application requires less CPU and memory resources
• All existing interfaces remain unchanged, ensuring seamless integration
• The database structure was preserved, minimizing migration complexity
• The entire renewal was accomplished without access to the original source code or documentation

How Does It Work?

The method operates by capturing and analyzing the application’s behavior in production or test. In this case, 150 million observations were collected, providing a comprehensive view of the system’s business logic, including:

• Interface specifications
• Data types and models
• Workflow patterns
• Data flow relationships
• Business rules, computation functions, and conditions
• State management and transitions

A key strength of the method lies in its ability to generate consistent code artifacts based on these observations. While it doesn’t yet automatically generate the complete application, it provides software engineers with substantial, well-structured and thoroughly tested code components that significantly reduce development effort and ensure consistency across the new system. This generated foundation allows development teams to focus their efforts where it matters most: implementing new business functionality that drives value, rather than getting bogged down in recreating existing features.

Beyond Simple Replacement

The true value of this approach lies in its risk reduction and additional benefits:

• It creates a clear, explorable overview of business logic that both analysts and engineers can understand
• Generated code artifacts provide a solid foundation for development, ensuring consistency
• The new application can adopt modern architectural patterns without being constrained by legacy design decisions
• Technical debt is naturally eliminated rather than carried forward
• Parallel testing capabilities ensure functional equivalence (validated with 40 million parallel observations in this case)
• Development teams can focus on business innovation rather than system reproduction

The Future of Software Renewal

While this proof of concept focused on a smaller system, the methodology shows immense promise for larger-scale applications. By dramatically reducing the risks typically associated with modernization projects and providing automated code generation capabilities, it opens new possibilities for tackling complex legacy systems. The ability to proceed in measured steps makes it particularly valuable for complex application environments where big-bang replacements are impractical.

For organizations grappling with legacy system modernization, this approach offers a promising path forward. It combines the security of maintaining existing interfaces and business functionality with the freedom to embrace modern technologies and architectural patterns, all while providing unprecedented visibility into system behavior. Most importantly, it frees up valuable engineering resources to focus on new business capabilities that drive competitive advantage, rather than spending months or years merely recreating existing functionality.

As we continue to see rapid advancement in technology, having reliable methods for system modernization becomes increasingly crucial. This source-code free renewal approach might just be the breakthrough many organizations have been looking for in their modernization journey.