Enabling Communication via APIs for Mainframe Applications

TL;DR

The paper tackles enabling API-based access to legacy mainframe applications by proposing a framework that automatically identifies candidate APIs from artifacts, computes precise API signatures through intra- and inter-program static analyses, and guides code refactoring to expose these APIs. It formalizes data-flow-based methods, proves soundness and precision, and integrates the workflow into IBM Watsonx Code Assistant for Z. Empirical evaluations on GENAPP and two industry applications, complemented by a qualitative study with nine experienced developers, show increased candidate API identification, reduced implementation effort, and viable execution on IBM Z with realistic latency. The approach enables scalable mainframe modernization to microservices while preserving SLAs and security controls, and it demonstrates practical viability through actual API execution and cross-application applicability. These contributions collectively advance automated APIfication, reducing manual effort and accelerating integration of legacy COBOL systems with modern cloud and API-driven architectures.

Abstract

For decades, mainframe systems have been vital in enterprise computing, supporting essential applications across industries like banking, retail, and healthcare. To harness these legacy applications and facilitate their reuse, there is increasing interest in using Application Programming Interfaces (APIs) to expose their data and functionalities, enabling the creation of new applications. However, identifying and exposing APIs for various business use cases presents significant challenges, including understanding legacy code, separating dependent components, introducing new artifacts, and making changes without disrupting functionality or compromising key Service Level Agreements (SLAs) like Turnaround Time (TAT). We address these challenges by proposing a novel framework for creating APIs for legacy mainframe applications. Our approach involves identifying APIs by compiling artifacts such as transactions, screens, control flow blocks, inter-microservice calls, business rules, and data accesses. We use static analyses like liveness and reaching definitions to traverse the code and automatically compute API signatures, which include request/response fields. To evaluate our framework, we conducted a qualitative survey with nine mainframe developers, averaging 15 years of experience. This survey helped identify candidate APIs and estimate development time for coding these APIs on a public mainframe application, GENAPP, and two industry mainframe applications. The results showed that our framework effectively identified more candidate APIs and reduced implementation time. The API signature computation is integrated into IBM Watsonx Code Assistant for Z Refactoring Assistant. We verified the correctness of the identified APIs by executing them on an IBM Z mainframe system, demonstrating the practical viability of our approach.

Figures (8)

• Figure 1: Mainframe APIfication Overview : Steps to APIfy a COBOL application include identification of code to be exposed, its refactoring, and computing its signature. It also includes refactoring of the caller code. Finally, it includes making the APIs production ready.
• Figure 2: Snippet from program LGTESTP1 of GENAPP to inquire motor policy. Lines 82 to 109 need to be exposed as an API. Requests and responses are marked for this API. Program LGIPOL01 is called from the code block.
• Figure 3: 6 variants to compute requests/responses using combinations of with/without call chain analyses and flow-sensitive/flow-insensitive/path-sensitive analyses.
• Figure 4: Analysis time in seconds of the four variants of computing requests and responses. These are GENAPP APIs explained in Section \ref{['sec:exp']}. FI and FS stand for Flow-Insensitive and Flow-Sensitive.
• Figure 5: Number of working storage + linkage section fields for requests and responses using the four variants of computation. These are GENAPP APIs explained in Section \ref{['sec:exp']}. FI and FS stand for Flow-Insensitive and Flow-Sensitive. Req and Res stand for Requests and Responses.

Theorems & Definitions (2)

• Theorem 1
• Theorem 2