A small summary of some key aspects of the approach to fixing the technical debt in your legacy application portfolio.
Risks of old technology in your software portfolio typically are:
- The development and operations teams have little or no knowledge of the old technologies and/or programming languages.
- Program sources have not been compiled for decades; modern compilers can not handle the old program sources without (significant) updates*.
- The source code for runtime programs is missing, or the version of the source code is not in line with the version of the runtime. The old technology to do static calls (meaning, including every called program statically in the runtime module) makes things even more unreliable.
- Programs use deprecated or undocumented low-level interfaces, making every technology upgrade a risky operation for breaking these interfaces.
A business case for a project to update your legacy applications can then be based on the risk identified in an assessment of your portfolio:
- An assessment of the technical debt in your application portfolio, in technical terms (what technologies), and volume (how many programs).
- An assessment of the technical debt against the business criticality and application lifecycle of the applications involved.
- An assessment of the technical knowledge gap in your teams in the area of technical debt.
The legacy renovation project
Then, how to approach a legacy renovation project.
- Make an inventory of your legacy.
- With the inventory, for every application make explicit what the business risk is, in the context of the expected application lifecycle and the criticality of the application.
- Clean up everything that is not used.
- Migrate strategic applications.
Make an inventory of the artifacts in your application portfolio:
- Source code: what old technology source program do you have in your source code management tools?
- Load module: what load modules do you have in our runtime environment, and in which libraries do these reside?
- Runtime usage: what load modules are used, and by which batch jobs, or application servers.
Assess the business risk
Consult the business owners of the applications. You may find they do not even realize that they own the application, or that there is such a risk in their application. The application owner then must decide to invest in updating the application, expedite the retirement of the application, or accept the risk in the application. In highly regulated environments, and for business-critical applications in general, the risks described above are seldom acceptable.
Next, unclutter your application portfolio. Artifacts that are not used anymore must be removed from the operational tools, throughout the entire CI/CD pipeline. It is ok to move things to some archive, but they must be physically removed from your source code management tools, your runtime libraries, your asset management tools, and any other supporting tool you may have.
Then, do the technical migration for the remaining applications. If the number of applications that must be updated is high, you often see that organization set up a “migration factory”. This team is a combination of business and technical expertise, that develops tools and methodologies for the required technology migrations. The remark here is that experience shows that more than 50% of the effort of such migrations will be in testing, and maybe more if test environments and test automation for applications do not exist.
Most compilers in the 1990s required modifications to the source programs to be compilable. The runtime modules of the old compiler, however, remained functioning. Many sites choose not to invest in the recompilation and testing effort.
Nowadays we accept we have to modify our code when a new version of our compiler or runtime becomes available. For Java, for example, this has always been a pain in the back, which is accepted.
For the mainframe, backward compatibility has always been a strong principle. Which has its advantages, but certainly also its disadvantages. The disadvantage of being an obstacle to technological progress, or in other words, the building up of technical debt, is often severely underestimated.