This post is a quick overview of an Abto Software’s blog article.

In the recent years, computer technology and innovation has been taking over almost every large industry. Programming languages and tools, frameworks, architectures, and other essential components are either becoming deprecated or losing technical support.

With updates, the probability of deployed legacy software not functioning as intended increases dramatically. In the best scenario, the implemented legacy software will still remain operational, but behind the scenes, lacking functionality, performance and stability issues, security vulnerabilities, and other potential problems will cause serious damage.

Problem outline

Let’s picture you’re utilizing legacy software to manage your day-to-day operational processes and customers. In case the product gets obsolete, you will likely face several challenges, which include proper maintenance.

Over time, with that legacy solution in place, your productivity, customer services, and security will deteriorate. That’s when the product will cause reputational and financial losses.

Yet still, software modernization is requiring solid investment, isn’t it?

Not necessarily – enterprise applications can be successfully optimized even without massive expenses.

Extension-based design: The pros and cons

One way to modernize your platform is implementing extensions-based design:

• New features are added no matter the technology behind the legacy product
• New features are executed in a separate process
• Customer issues can be fixed quickly by introducing new extensions
• Different components can be based on different technologies
• Separate modules or components make the software development more manageable
• Separated functionality reduces complexity simplifying maintenance and troubleshooting

Yet still, there are some downsides to consider before applying extensions-based design:

• Messy communication between extension and the legacy product
• Complex infrastructure
• Deteriorated performance
• Harder maintenance and debugging

Legacy software case example

Let’s suppose we’re dealing with existing enterprise-level software, enabling seamless workflow modification. It provides data sharing and retrieval, file manipulations, email management, advanced analytics and reporting.

All modules of the described application are integrated into one monolithic system and thus highly connected. That means adding and modifying steps might cause severe issues to the whole system.

Another aspect worth mentioning – despite the named problems, the system is typically functioning correctly. Most issues usually concern certain steps being dysfunctional in some specific environments, causing damage to the entire system.

Considering that complete refactoring will incur unjustified expenses, how can we approach such architecture to leverage:

• Smooth integration
• Backward compatibility
• Reduced risks
• Increased productivity?

Extensions-based design to resolve specific issues

To resolve identified challenges, we suggest to create an application that will handle one specific problem. Speaking about the case described earlier – an application, which could handle the two-way communication with the SAP platform.

For example, we could smoothly implement each step using either .NET 6 or Node.js.

The benefits of this extensions-based design might include:

• Cross-platform compatibility
• Cloud integration
• Enhanced scalability
• Improved security

The concepts to note:

• Host – core product in a particular domain to extend
• Extension – separate application extending the parent system
• Extension manifest
• Activation events
• Contribution points
• Extensibility API
• Entry API

The host (core product) can find suitable extensions by searching for the JSON files in the determined directory. The extension (separate application) is represented by the JSON manifest, which follows predefined schemas and declares the name, solution version, and instructions for the integrated extension.

After the extension discovery, the host can launch executable processes using information from the JSON file. That way, the host can establish inter-process communication between extensions and processes within the parent system.

So now, how do we integrate the application with the legacy software that’s written in a different technology? Quite simple – by implementing software extensions.

The integration is performed in the following steps:

1. The refactoring of the legacy software
2. The conversion of the SAP application
3. Integration testing to verify backward compatibility

Final words

One example of successful extensions-based design are all modern-day browsers, in particular Google Chrome. It supports various applications allowing end-users to customize their daily browsing experience, add features, and, accordingly, enhance productivity.

This approach enables flexibility, reduced time and cost, customer-centric innovation, minimized risks, enhanced performance, and future-proof, long-term scalability.