Last year, IBM demonstrated how AI can do the repetitive work of maintaining software by updating legacy code. The company has now introduced AI-based techniques for re-encoding legacy applications to run on modern computing platforms.
Recent IBM projects called Mono2Micro and Application Modernization Accelerator(AMA) provide application architects with the tools to update and reuse legacy applications. According to Nick Fuller , director of hybrid cloud services at IBM Research, these initiatives are helping to bring AI closer to the point where AI can automatically migrate from COBOL to Java.
But Fuller notes that these advanced AI-based approaches are currently only capable of breaking legacy machine code of monolithic programs into discrete microservices. One more step remains to complete a full translation from one programming language to another, because the AMA toolkit, although designed to modernize COBOL, currently only provides another step in this process. “Translating from one language to another is a fundamental challenge for AI, which we are working on to make some of this legacy code function in a modern programming language,” he added.
In the meantime, IBM's advanced AI-powered tools offer some new capabilities. As for Mono2Micro, this tool first analyzes the old code to reveal any hidden connections within it, for example, various components in the underlying business logic that contain numerous calls and connections to each other. It would be very difficult and time-consuming for an application architect to complete such a task on his own.
Mono2Micro uses AI-based clustering techniques to group similar codes into groups, which more clearly shows how groups of codes interact. Mono2Micro first accepts the code, then parses the source and object code both statically (by analyzing the program before it runs) and dynamically (by analyzing the program while it is running).
The tool then converts the Java-based monolithic programs and their associated business logic and user interfaces into microservices. Refactoring the monolith into separate microservices with specific functionality minimizes the connections that existed in the software when it was a monolithic program by changing the structure of the application without changing its external behavior.
The purpose of the AMA toolkit is to both analyze and refactor previously developed applications written in legacy languages (COBOL, PL / I). As for the AMA toolkit, it combines static analysis of the source code with an understanding of the structure of the application to create a graph that represents the legacy application. When used in conjunction with deep learning techniques, this graph-based approach facilitates data persistence.
Image: IBM Research
Image of Mono2Micro interface
IBM's AI strategy addresses the key challenges in machine learning where the inputs are code and the parameters for analysis are volume and multiple values. Critical legacy applications typically contain hundreds of thousands to millions of lines of code. In this context, applying machine learning (ML) techniques to such large amounts of data can be made more efficient with the concept of embedding.
These embedding layers are a way to convert data to numeric values. The advantage of the embedding method is that it allows you to assign a numeric expression to a large amount of code with many possible values. The same happens, for example, when translating natural human language into numerical values using vector word embeddings. This is also done in the context of a graph, as it has to do with code parsing.
“Embedding layers are awesome because without them it would be hard to get anything that looks like an efficient machine learning system,” Fuller said.
He added that in the case of code analysis, the machine learning system each time better offers microservices for a refactored legacy application by replicating the functional content of the application.
Fuller notes: "At this point, you can't breathe out yet, but 70% of the work is behind you, which means you are much closer to refactoring an important application into a microservice architecture."