By Krasimir Baylov, Managing Partner, Intway
The software industry is moving forward today at an amazing pace – new technologies appear, cloud providers release new services that make developers’ lives easier. However, not all industries manage to keep up with this insane pace. Some of them prefer to stick to stability while sacrificing the usage of the latest and greatest technologies.
This has led to a completely new set of problems that organizations have to deal with today. Many of them run business critical applications built with technologies whose life cycle is close to their end. Others are using technologies that are too old to satisfy market needs. So, what do such organizations do to survive? How do they modernize their infrastructure, technology and look and feel? In this article, we’ll discuss the top 5 trends in modernizing old applications.
1. User Interface Modernization
Large systems are extremely hard to refactor or replace. They have extremely complex processes and the user interface is outdated and hard to use. In such cases, many organizations try to minimize the risk of potential problems on backend modernization and try to maximize the benefits in terms of improved user experience.
Think of an old banking system written on Cobol and some basic desktop user interface. In order to modernize the user experience, you could simply replace the user interface layer with some contemporary technology and styling – maybe React, Angular and some styling libraries.
While this is generally fine, this could introduce some additional problems to worry about – integration. What would you do if you plan to use modern REST APIs while the backend only supports RCP or some proprietary binary protocol? Don’t worry, point 2 provides a popular solution to this situation.
2. New Integration Layer – Middleware
Backend systems of legacy applications tend to be extremely hard to refactor or modernize. The quick wins are achieved through updating the User Interface. However, this could make your integration with the backend services challenging. More often than not, the backend supports outdated communication protocols that are hard to use from modern technologies. Some common issues that companies encounter are:
- Non-optimal message formats and granularity – usually legacy systems would use non-descriptive messages. They provide a lot of system codes instead of descriptions of the values which makes them hard to understand and troubleshoot. In addition, services could be too coarse or fine grained compared to what the new UI would expect.
- Error handling – legacy systems have their own way of handling system errors (if they have any). This requires a new way or dealing exceptional situations that make them more adequate to modern users.
- Security – while legacy systems could have pretty good security, they are not always up to date with the latest security exploits. Today, such systems need to be integrated with other (quite often, external) systems which requires rethinking the overall security from a global point of view.
So, apparently, refactoring or rewriting the backend is not that easy. It could be quite costly, too. To minimize the effect of frontend-backend inconsistencies, architects tend to provide a new integration layer. This integration layer serves as a middleware between the frontend and the backend. It hides the unnecessary details from the legacy backend and adds all system properties that are required by modern applications. This includes but is not limited to – improved security (authentication & authorization), error handling, logging, aggregating and transforming messages, etc.
Most importantly, implementing this integration layer is much cheaper than refactoring or completely replacing the legacy backend.
3. Infrastructure Modernization
Most legacy systems are hosted on-premise and run on old hardware. Like it not, today infrastructure plays a significant role in fulfilling business requirements. Proper infrastructure could be the enabler for key characteristics like scalability, performance, extensibility, portability, etc. Just think about it. Old on-premise hardware requires a lot of manual effort from your infrastructure team. Dynamic scaling is hardly achievable in an optimal way. But that’s not the big problem. It gets harder and harder to find people to support the legacy hardware. Moreover, legacy infrastructure becomes the main bottleneck that affects speed of delivery.
Moving to a modernized infrastructure is a trend that introduces a lot of benefits. However, it is important to note that this, often, requires architectural changes in order to embrace them. Below are some of the main benefits that modernized infrastructure introduces:
- Performance – using better processors, memory, storage, etc. increases the overall performance of the system.
- Scalability – modern infrastructure supports scalability in a better way. You could use cloud infrastructure or run your own Kubernetes clusters to deal with sudden bursts in system load.
- Speed of delivery – using modernized infrastructure could enable your teams to work in parallel. They could release new features faster with less coordination with other teams.
- Stability – automated monitoring and CI/CD (continuous integration & continuous delivery) processes allow you to determine errors as early as they are introduced or appeared.
As mentioned, infrastructure modernization is often accompanied by architectural modernization. For example, consider modernizing the infrastructure of an old monolith application. You will not get all benefits, unless you consider splitting the monolith or even introducing a full-fledged microservice architecture. In many cases, you will need to add separate infrastructure components or deploy certain parts of the system on separate nodes.
4. Process Modernization
In many situations, modernizing your technology is not enough. As your business grows and matures, there are more and more processes that you support. Many of them are manual processes, while others require automation optimization in order to be relevant. So, there are two important points that should be considered when modernizing your processes
- Update your processes – make sure that your procedures are up to date. No matter whether manual or not, they should reflect a valuable business process. Even the most technologically advanced system makes no sense if it’s using outdated or wrong processes.
- Digitize your processes – once you know that your processes are up to date, you should consider digitizing them. You could use technology to either support the manual steps or fully automate them where applicable.
5. Evolutionary Modernization
This is what all organizations should aim at. Unfortunately, many of them simply ignore the importance of introducing regular incremental modernization steps and they end up with the big bang modernization approach described in the previous points.
Your organization should make small incremental updates over a regular period of time. Make sure that you are up to date with the relevant technology trends. It’s much easier to switch from version 2.1 to 2.2 for a certain technology rather than migrating from 2.1 to 7.0, for example.
Well, at some point, your technology may reach the end of its life cycle. Or it may not be relevant to your business case as a new technology arises. To mitigate the risk, you should always be aware of the technology trends and take any preventive actions earlier. Do not wait for the very last moment to make the shift and start preparing for it early and in small incremental steps.
Application modernization is getting more and more popular today. The insane speed of technology development makes systems outdated within years…even months. Systems that we built a decade ago are already showing their age. What’s more, they are not that easy to replace by a completely new system because they are tightly coupled to other systems and complete rewriting would be extremely expensive. This forces companies to search for means for modernizing the components that bring most value to the business while minimizing the negative impact.
As software architects, we should always keep in mind that technologies evolve and we should always strive to design systems that incorporate this external technological and business evolution.