Modernizing COBOL: From Mainframe to API
Key Points
- Legacy mainframe COBOL systems still power critical business functions but are tangled in monolithic code, 3270 screens, batch jobs, and hidden business logic, making them hard to evolve.
- The first step to modernization is to map the entire application landscape with tools like ADDI (Application Discovery and Delivery Intelligence) and its Refactoring Assistant, identifying data flows, batch schedules, and the specific logic embedded in screens and transactions.
- Using that insight, you can extract and re‑implement isolated services that expose the same APIs as the original COBOL code, allowing automated testing and a cleaner, more maintainable code base.
- Refactoring these services not only reduces technical debt but also opens the door to integrate advanced capabilities—such as AI inference—directly into the processing pipeline, especially when leveraging hardware like the Telum processor for inline AI execution.
- The overall payoff is a modernized, service‑oriented architecture that delivers faster, more efficient business value while preserving the functional correctness of the existing legacy system.
Sections
- Transforming Legacy COBOL Systems - The speaker explains the challenges of massive, interconnected COBOL mainframe applications and outlines a three‑part approach to migrate them into a modern, service‑oriented architecture for greater business value.
- AI‑Driven Refactoring for Legacy Systems - The speaker explains how AI tools such as Watsonx Code Assistant, combined with Telum processors, enable inline AI processing and API‑based transaction handling to modernize legacy mainframe applications, reduce technical debt, and streamline batch workloads.
Full Transcript
# Modernizing COBOL: From Mainframe to API **Source:** [https://www.youtube.com/watch?v=-CI8hb-077E](https://www.youtube.com/watch?v=-CI8hb-077E) **Duration:** 00:05:43 ## Summary - Legacy mainframe COBOL systems still power critical business functions but are tangled in monolithic code, 3270 screens, batch jobs, and hidden business logic, making them hard to evolve. - The first step to modernization is to map the entire application landscape with tools like ADDI (Application Discovery and Delivery Intelligence) and its Refactoring Assistant, identifying data flows, batch schedules, and the specific logic embedded in screens and transactions. - Using that insight, you can extract and re‑implement isolated services that expose the same APIs as the original COBOL code, allowing automated testing and a cleaner, more maintainable code base. - Refactoring these services not only reduces technical debt but also opens the door to integrate advanced capabilities—such as AI inference—directly into the processing pipeline, especially when leveraging hardware like the Telum processor for inline AI execution. - The overall payoff is a modernized, service‑oriented architecture that delivers faster, more efficient business value while preserving the functional correctness of the existing legacy system. ## Sections - [00:00:00](https://www.youtube.com/watch?v=-CI8hb-077E&t=0s) **Transforming Legacy COBOL Systems** - The speaker explains the challenges of massive, interconnected COBOL mainframe applications and outlines a three‑part approach to migrate them into a modern, service‑oriented architecture for greater business value. - [00:03:03](https://www.youtube.com/watch?v=-CI8hb-077E&t=183s) **AI‑Driven Refactoring for Legacy Systems** - The speaker explains how AI tools such as Watsonx Code Assistant, combined with Telum processors, enable inline AI processing and API‑based transaction handling to modernize legacy mainframe applications, reduce technical debt, and streamline batch workloads. ## Full Transcript
Today you have those large mainframe COBOL applications
that are providing you really large critical business value,
but they're locked in this web of interconnectedness and are hard to deal with.
So where do you go with that?
What we want to talk about today is how to take that
millions, if not hundreds of millions of lines of code of COBOL
and bring it into the modern world
and help you have these services aligned for your organization
to drive better business value more efficiently.
So I'm going to explain this to you in three parts.
You're here today.
Where to start, and what the payoff is.
So let's think about our applications today.
We have large application databases.
This is where we store all the data related to this nice monolithic application.
And it's connected to a transaction server.
And you probably still have a whole bunch of those 3270 green screens in that code,
whether or not people are using them today or not, you still have this all in the code.
And then you have a set of batch processes as well.
So today you may have put an API here
and you may be using that API to go through this process to get to this function.
But that API is dependent on all of this logic and all of this code
because you have business logic hidden in these transactions, in this 3270 interface.
And you have this batch processing that could be being fed part of the day over and over again,
and then it batches up and processes at night.
So you've got this process that works.
It's driving your business, but it's not the most effective and efficient.
So where do you start?
You take a look at all of this application.
Use tools like ADDI (Application Discovery and Delivery Intelligence)
to understand how all these pieces fit together.
What is your batch schedule?
What are the applications?
And you look at this data and figure out,
using the refactoring assistant that's part of ADDI,
you can look at this and understand what is the flow that provides this value?
What are the pieces of the business logic that's sitting in the screens,
the transaction, what's that data?
And is there an appropriate piece from this side as well?
And you can take that stream and pull it out of the existing code.
And now I can have a new COBOL application that's exposing this exact same API.
So I can use whatever automated testing I have
to make sure that I'm building the function in a streamlined way.
So that's where we are today, and a little bit about where to start.
But now why?
What's the real reason for doing this?
Yes, this removes technical debt.
This makes it easier to maintain.
But let's think about it.
AI and the AI world that's hitting us today.
This transaction, if I could put AI right here,
right in the middle, effectively and efficiently,
which I can with a Telum processor, I can do inline processing.
With this refactored service it's so much easier
to put the processing in line in that logic rather than,
"Oh, does it really need to go in the business logic that's sitting here in this screen?"
"It's really hard to do."
So thinking about our applications and thinking about the fact we want to modernize.
By using the refactoring assistant,
by working with ADDI and working with a new watsonx Code Assistant for Z,
we can help modernize these transactions,
bring this together to truly provide even better business value
with our existing application logic.
And then we also have to deal with this batch environment,
these files or things that are coming in.
Well, guess what?
I now have this simplified API.
Instead of putting a file on the system and running it through batch,
I can just send it to that API as well and I can do that in line.
Now we still have a need for batch.
We're still going to do our end of day processing with our batch processing,
but we can do many more of the transactions in line as part of this activity.
Getting started and moving in this direction
allows us to truly take advantage of this logic that's been there for years
that's providing key critical business value
- but it's locked in this mess.
It makes it so much easier for us now expose and bring AI into the picture.
So hopefully you see a little bit of that payoff to this modernization effort.
And hopefully you see that by truly looking at our existing applications
and the assets that we have, we can pull out and use those pieces
to drive new business opportunity and new business value.
Check it out.
Take a look at the ADDI and the capabilities of watsonx Code Assistant for Z,
and join me on the journey of modernizing your applications.
Thanks for watching.
For all you mainframe fans out there,
don't forget to click "like" and subscribe
so you won't miss my next video.