An AI alternative to code search tools

COBOL Colleague uses symbolic machine learning and static analysis to help developers understand and maintain COBOL source code. The same technology could be applied to other programming languages.

A human profile containing digital wireframe of technology connections.
Sadsadang / Getty Images

Like any other discipline, software development has its productivity challenges. Would you believe that the average software developer spends roughly 75% of their time just searching through and understanding code to make necessary changes?

With developers spending so much time and effort on just getting their bearings, before any real work gets done, they have less time and energy to apply toward conceiving creative solutions to difficult development challenges. And between the growing global shortage of skilled developers and the pressing need to update applications frequently to support constantly changing business demands, we need developers to be as productive as possible.

Thanks to artificial intelligence, tools are becoming available to close the application knowledge gap for developers, promising to exponentially improve developer productivity across applications. COBOL Colleague, from Phase Change Software, is an AI-driven tool that helps developers to quickly gain a mental model of a COBOL codebase, and to zero in on the exact code they need to change.

For the many organizations that rely on legacy mainframe applications, COBOL Colleague could empower them to immediately access lost application expertise and regain intellectual control of their applications. In the future, the same technology could be applied to any other programming language.

This article will dive deeper into the challenges faced by the developers who maintain mainframe applications, assess the shortcomings of existing tools, and explain how COBOL Colleague enables day-one competency for developers who work with COBOL source code.

Modernizing mainframe applications

Countless organizations continue to depend on legacy applications to power several core business functions. With many of the world’s top banks, largest insurance companies, biggest retailers, and the vast majority of Fortune 500 companies leveraging mainframes to conduct their businesses, mainframes still handle about 68% of the workload running the world’s production for mission-critical workloads. All of those applications can’t simply remain static as these businesses grow and mature. 

Unfortunately, maintaining the mainframe applications that reliably complete trillions of transactions every day faces growing risks. As experienced developers retire or move on, the specialized industry and institutional knowledge that enables developers to effectively maintain and support complex critical systems disappears, making applications difficult to safely update and organizations increasingly vulnerable.

Additionally, many modernization projects incorrectly assume that an existing application’s code is correct and that its functionality can be precisely captured by analysts and programmers. More often than not, however, these source code repositories with millions of lines of code contain vast amounts of dead and inefficient code and old business rules that no longer apply. The result? Short-sighted “solutions” built on or around existing code, creating increasingly unwieldy systems that are even more challenging to change and maintain without significant risk.

Even when an organization already has a maintenance strategy in place, that plan of action likely focuses on finding developers with specific language knowledge. It typically does not address the larger problem: the loss of the application knowledge necessary to maintain critical applications. Whether through collaboration with a veteran developer who possesses intimate knowledge of the system, or by using traditional code search and static and dynamic analysis tools, developers who are new to a system typically require 18 months to get up to speed to making production-ready changes. Most companies can ill afford to wait through that much on-the-job training before a developer is ready to repair and update their critical legacy applications.

Inadequate traditional tools

Compounding the issue, our current code search tools, linters, and static and dynamic analysis tools are all insufficient in identifying the specific lines of code that require attention—especially considering the frequently cumbersome level of code entanglement seen throughout a system. These tools enhance developer efficiency, but those improvements are only incremental.

Whether localizing bugs, enhancing programs, or adding functionality, many modern software development tools can analyze millions of lines of code, flag errors, and suggest fixes or offer best practices. However, even when using these tools,  developers still have to rely on their human cognition to properly assemble the found or flagged code snippets to effectively make changes that won’t result in any downtime or other disastrous effects. Worse, humans are fallible. This time-intensive, mentally taxing, cognitive labor doesn’t always deliver the “right” answer. In fact it’s prone to introducing errors.

Consider a compliance update as an example. Security vulnerabilities can be simple enough to identify with current tools, but narrowing in on the pertinent code to update to remain compliant can be more difficult and time-consuming than rewriting the program from scratch. With the relevant code sprinkled across several files, developers have to consider why a program behaves in a certain manner so that they can conceptualize that question into a series of actions and queries to find the problematic code and address the compliance issue to be updated. Whether removing files from the search, isolating chunks of code that might be relevant, simulating the logic, or doing a dependency analysis, developers also need to keep in mind the relevant data in each line of code—and the number of lines involved could be expansive. Additionally, developers must actively exclude the lines of code that they don’t think are relevant (and they could be wrong about that) before assembling the pieces in their heads.

Even the most talented and experienced software developers struggle to simultaneously keep track of disparate and related aspects of a detailed program execution path amidst all of the code they deem irrelevant. Consequently, debuggers are not as widely used as expected in functional programming environments.

Perhaps worst of all, even the most state-of-the-art tools don’t communicate how changing code in one area of the program will impact the application overall. There’s no cognition or forward simulation of the execution of code, a capability that would most certainly be useful to a developer.

Software developers new to a system still have to mentally model what the code does to reveal the behavior that needs to change. If developers were equipped with a tool that has that knowledge, and makes it seamlessly available, they could rest assured knowing that any change they’re about to make will not break the entire system.

Collaborating with an AI co-worker

An AI partner for mainframe developers, COBOL Colleague uses intelligence augmentation to instantly close this application knowledge gap. Using symbolic machine learning on application code, COBOL Colleague differs from traditional tools because developers merely have to “ask” for the behavior, and the correct code and data necessary to replicate the sought behavior is immediately returned to them. COBOL Colleague is an AI agent that understands what the application’s previous developers knew when they created and modified the application, and it excels at sharing its knowledge while collaborating with developers.

For example, one common approach to bug fixing is seeking out the code that works correctly so that developers can use that as a basis to find the code that works incorrectly. From there, developers can mentally compare the two. Without COBOL Colleague, developers must track the code and the associated data that performs both behaviors and mentally compare the processing that takes place. The comparison that the developer does is not a simple code diff.

By contrast, COBOL Colleague’s Semantic Diff feature leverages the inherent capability of producing a simulation trace of the execution path of the code and associated data for when the code is working correctly and when the code is working incorrectly. Going well beyond textual comparison, these simulation traces enable developers to adequately compare behaviors within a looping structure construct. There may be cases where the incorrect functionality only surfaces on the second iteration of a loop, so while text comparison doesn’t help you to see that, COBOL Colleague does.

COBOL Colleague uses intelligence augmentation to reinterpret what the computation represents and convert it into easy-to-understand concepts that are surfaced to the developer in a timely and intuitive way, thereby eliminating the need to manually search through millions of lines of code to identify troublesome behaviors. By employing AI in this way, COBOL Colleague transforms the code repository into a knowledge repository that represents source code in the same way a human thinks about it: in terms of cause and effect. That representation aligns with what developers are ultimately seeking, which is the code and associated data.

An AI agent that learns from COBOL source code, gathering the knowledge necessary to comprehend any complex and critical mainframe application, COBOL Colleague helps mainframe developers safely, efficiently, and effectively isolate production code defects, identify code requiring regulatory compliance changes, and mitigate the risks involved in modernizing their mission-critical legacy applications.

By harnessing COBOL Colleague, companies can empower their software development teams to think creatively, sustain productivity while learning the application, and move on to more thoughtful tasks. No, COBOL Colleague is not sophisticated enough to take a developer’s job. Instead, the tool amplifies a developer’s skills, unleashes their creativity and radically improves productivity—from the first day on the job.

Steve Brothers is president of Phase Change Software. Steve has more than 30 years of experience in technology-related organizations with leadership, technical, and sales roles in industries such as financial services, healthcare, and software development tools. Previously, Steve held positions as CEO at Ajubeo and executive vice president and CIO for Urban Lending Solutions. Steve graduated from the University of Colorado at Boulder and holds a B.A. in Philosophy and a B.S. in Information Systems.

New Tech Forum provides a venue to explore and discuss emerging enterprise technology in unprecedented depth and breadth. The selection is subjective, based on our pick of the technologies we believe to be important and of greatest interest to InfoWorld readers. InfoWorld does not accept marketing collateral for publication and reserves the right to edit all contributed content. Send all inquiries to

Copyright © 2022 IDG Communications, Inc.