Modernize your legacy code with Go4IT Alight

The discovery phase enables Go4IT Alight to gain knowledge of the legacy programs being analyzed. This process is very similar to what a compiler does, but reaches a deeper level of understanding. Alight first discovers the structure of the analyzed source code, identifying variables, functions, and classes. It then analyzes the behavior of each function, reaching the same level of detail as a compiler. Finally, the discovery process obtains information about the data model used by the programs — accessed databases and tables, as well as data files — and about the user interface of the application windows, including dialogs, controls, buttons, and more. The result of this process is a technology-independent representation based on Alight’s Pivot Language.

One of Alight’s key features is its flexibility. This allows us to customize the discovery process by introducing elements specific to each installation, such as custom UI components, special libraries, and more. As a result, we can develop modernization solutions that faithfully preserve the architecture of the applications, reducing the learning curve for the future maintenance team.

Alight’s analysis phase makes it possible to obtain information from the source code. This information is crucial for a successful modernization, as it helps identify structural, performance, and other issues in the applications and apply corrections before transforming them to a new platform. Alight currently includes a wide range of analysis tools available for all programming languages:

• dead code and unused variable detectors
• cyclomatic complexity report generators
• detectors of business logic embedded in user interface windows
• program dependency extractors
• flowchart extractors
• data model analyzers

In addition, custom static analysis algorithms can be developed to address the specific issues of each installation.

The last two phases of Alight allow the tool to automatically generate a functional replica of the source application in the desired target technology. Obtaining the final application consists of two phases. The first aims to prepare the code for the new platform: the optimization phase.

The optimization phase allows Alight to perform a series of formal modifications to the code so that it can be regenerated in a specific technology. For example, before generating Java code, it is necessary to ensure that there are no GOTO statements in the source language. This process can also be used to optimize generation for a specific technology. For example, when transforming an old Visual Basic application into HTML5 + CSS, size calculations will be required to obtain a responsive interface.

The optimization phase is closely linked to the generation phase and also to the characteristics of the target platform.

Alight includes state-of-the-art code generators that make it possible to link intermediate language models with modern target languages such as Java, shell script, HTML, JavaScript, Python, and others. In addition, Alight can regenerate code in the original source language for automatic source code correction use cases, such as removing GOTOs in COBOL.

Thanks to its great flexibility, these generators can be customized to take into account elements specific to each installation, allowing us to achieve 100% automation across the entire migration process.