AI-Powered Mainframe Modernization: Converting IBM Assembler TPF to Java Spring Boot

Introduction

Modernizing legacy mainframe systems like IBM TPF (Transaction Processing Facility) is a critical challenge for many organizations. TPF Assembler applications are often deeply intertwined, with complex dependencies across programs and data structures. Translating this logic to a modern, cloud-native architecture requires a sophisticated approach to manage these dependencies. Leveraging AI-driven tools and dependency mapping in a graph database can help retain the integrity of business logic during modernization.

This article demonstrates how AI can assist in translating a TPF Assembler program that adds two numbers into an equivalent Java Spring Boot application, while using a graph database to track program dependencies and data flows.

Step 1: Mapping Dependencies with a Graph Database

In legacy TPF environments, system calls often span multiple programs, data blocks, and interactions that are hard to track manually. By storing dependencies in a graph database, we can visualize relationships and identify potential bottlenecks, redundant code, or data dependencies, which streamlines the translation process.

1. Dependency Extraction:

   • AI-driven analysis tools scan assembler code to extract dependencies between programs, functions, and data blocks (e.g., MI0MI, OUTPUT, ENTNC calls).

2. Graph Database Structure:

   • Store each program as a node and define edges for each dependency (e.g., ENTNC calls, shared data blocks).
   • Link nodes to show dependencies (e.g., SYSTEM_ENTRY -> ADD_NUMBERS -> DISPLAY_OUTPUT), making it easy to analyze and optimize the translation to Java.

3. Use Case in Modernization:

   • By querying the graph database, developers can view the entire program flow and easily identify components to be rewritten in Spring Boot, ensuring no business logic is lost.

Step 2: TPF Assembler Code Example with System Programs

In TPF, assembler programs often go through several system programs to handle requests. Here’s a sample flow:

1. TPF System Entry Program:

   • The entry point processes the initial request, routes it to the appropriate program, and loads input values.

2. ADD_NUMBERS Program:

   • This specific program performs the addition. It reads input from MI0MI memory block, processes it, and stores the result in an output block.

3. Output Display Program:

   • Finally, the TPF system program is called to move the result to the user’s screen or designated output.

TPF System Programs and Main Addition Program

TPF Assembler Code:

ENTRY SYSTEM_ENTRY  
         * Load inputs and route to addition program  
         L     R1,=A(MI0MI)       * Load address of input memory block  
         ENTNC ADD_NUMBERS        * Call the addition program  

ENTRY ADD_NUMBERS  
         L     R1,MI0MI+0         * Load first number into register R1  
         L     R2,MI0MI+4         * Load second number into register R2  
         AR    R3,R1              * Add R1 and R2, store in R3  
         ST    R3,OUTPUT+0        * Store result in output block  
         ENTNC DISPLAY_OUTPUT     * Call output display program  

ENTRY DISPLAY_OUTPUT  
         L     R4,OUTPUT+0        * Load result from output block  
         * Code to print R4 to the screen  
         BR    R14                * Return to calling program  

Explanation:

• SYSTEM_ENTRY handles input retrieval and routes the call to ADD_NUMBERS using ENTNC.
• ADD_NUMBERS processes the data and calculates the result, then uses ENTNC to call DISPLAY_OUTPUT.
• DISPLAY_OUTPUT fetches the result and moves it to the screen.

Step 3: AI-Generated Java Spring Boot Equivalent

Using AI to translate TPF Assembler logic, we create a Java Spring Boot equivalent that handles input, processes data, and returns output in a RESTful format.

Java Spring Boot Code:

@RestController  
@RequestMapping("/api")  
public class CalculatorController {  

    @GetMapping("/add")  
    public ResponseEntity<Map<String, Integer>> addNumbers(  
            @RequestParam("num1") int num1,  
            @RequestParam("num2") int num2) {  

        int result = num1 + num2; // Sum of the two numbers  
        Map<String, Integer> response = new HashMap<>();  
        response.put("result", result);  

        return ResponseEntity.ok(response);  
    }  
}  

Explanation:

• @RestController defines a RESTful controller.
• @GetMapping(“/add”) maps GET requests to /add.
• @RequestParam retrieves num1 and num2 from the URL.
• int result = num1 + num2 performs the addition, and the result is returned in JSON, similar to the output display in TPF.

Key Benefits of AI-Assisted Modernization with Dependency Mapping

1. Preservation of Business Logic: AI and dependency mapping in a graph database help retain critical logic while translating to a modern language.
2. Improved Scalability: With Java Spring Boot, the application can scale horizontally, addressing limitations in the mainframe environment.
3. Reduced Complexity: Storing dependencies in a graph database allows for easier understanding and documentation, enabling smoother handoffs to development teams.

Conclusion

AI-driven modernization from TPF Assembler to Java Spring Boot allows organizations to retain essential logic while transitioning to scalable, cloud-native architectures. By mapping dependencies with a graph database, businesses gain visibility into complex program flows, ensuring a comprehensive and reliable translation process. This approach preserves core functionality while unlocking the flexibility of modern infrastructure.