Bridging JCL and APIs in Mainframe Modernization
Mainframe development sits between two realities. On one side, there is the traditional world of JCL, structured batch processes, and deterministic workflows. On the other, we see the rise of API-driven automation, where Python, Git, and DevOps pipelines shape how software is built and delivered.
Both worlds ultimately pursue the same goal: stable, transparent, and reliable software processes. Yet, how developers achieve that goal has changed significantly over time.
Two Worlds, One Outcome
A simple experiment highlights this contrast.
I implemented the same classic mainframe workflow twice:
1. Assembling a program.
2. Performing the link-edit step.
3. Executing the resulting binary.
The first implementation followed the traditional approach using JCL, just as it has been done reliably for decades. The second used Python with ZOAU, leveraging functions like mvscmd.execute() and jobs.submit() to control each step programmatically.
The result in both cases was identical. The program assembled correctly, the link-edit step completed successfully, and execution ran without issue.
From a purely technical perspective, nothing changed. The real difference was how the process was described and controlled.
JCL vs. APIs: What Actually Changes
The JCL version made the workflow extremely transparent. In just a few structured statements, it clearly showed which programs were invoked, which datasets were used, and how each step connected. For experienced engineers, this transparency is part of what makes the platform so reliable.
JCL doesn’t just run jobs. It documents how the system operates.
The Python version offered a different advantage. The entire process could be structured inside a script, enhanced with error handling, conditional logic, and flexible automation. Feedback could be captured programmatically, and the workflow could integrate directly into modern CI/CD pipelines.
In this model, the process becomes dynamic, programmable, and aligned with modern software engineering practices.
What I noticed was that the real distinction wasn’t technology, it was mindset.
The Real Problem Isn’t Technology
Both approaches work.
Traditional environments emphasize stability, predictability, and operational transparency. Modern environments prioritize automation, integration, and continuous delivery.
The real question is not “JCL or APIs?”
The challenge is how to bring both worlds together without losing knowledge or adding unnecessary complexity.
Mainframe organizations hold decades of expertise, proven processes, and systems that run mission-critical workloads. At the same time, expectations around automation and DevOps continue to evolve.
Where IBM Bob Fits In
This is where IBM Bob enters the conversation.
IBM Bob acts as an AI-assisted development partner, helping engineers analyze code, understand system context, and automate workflows across the lifecycle. From planning to generation to analysis, it supports developers in working through complex tasks more effectively.
What makes this different is that Bob does more than generate small snippets. Bob actually helps developers understand architecture, context, and relationships inside complex systems.
That matters to those of us working on the mainframe, where applications often evolve over decades and contain deeply interconnected business logic.Modernization Without Replacement
Today, mainframe modernization rarely means replacing systems outright. It’s too fraught.
The real challenge to modernization, then, is understanding existing applications, exposing hidden dependencies, and integrating them into modern workflows.
An intelligent assistant like IBM Bob can help bridge that gap. It supports developers in analyzing legacy code, identifying modernization opportunities, and introducing automation without disrupting proven systems.
The Generational Shift in Mainframe Development
Another factor makes this even more urgent: the generational shift across the ecosystem.
Experienced professionals bring deep system knowledge built over decades. New developers arrive with different expectations: Git, APIs, containers, and CI/CD pipelines are their baseline.
Concepts like JCL and traditional batch workflows are often unfamiliar territory.
But the principles behind them—stability, discipline, and architectural clarity—are exactly why mainframes continue to run the world’s most critical systems.
The challenge is not replacing this knowledge. It’s making the knowledge accessible.
“Modernization isn’t a technology problem, it’s a continuity problem.”
AI-assisted tools help surface hidden knowledge, explain complex relationships, and guide developers through unfamiliar codebases. In doing so, they increase productivity and enable knowledge transfer across generations.
The Real Risk: Losing Knowledge or Falling Behind
The most sustainable path to modernizing the mainframe combines the strengths of established architectures with the flexibility of modern development practices.
Reliability and automation can—and should—coexist.
That’s the philosophy behind IBM Bob. Rather than replacing proven processes, it helps developers understand them, automate them, and integrate them into modern environments.
In that sense, IBM Bob represents something bigger than a tool. It’s a bridge between experience and innovation, between stable architecture and modern engineering practices. Ultimately, mainframe modernization is is about mindset, knowledge, and connection.
If you modernize without integrating, you lose knowledge.
If you preserve without automating, you lose the future.
Read more about Uwe’s experiences testing IBM Bob AI with COBOL, PL/I, Assembler, and JCL
0 Comments