CobolBridge is a software tool that allows organizations to combine maintaining COBOL code with executing Java/C#. This makes it possible for developers to make the transition to Object-Oriented languages such as Java or C# gradually over time, for example team by team.

The solution provides an efficient transformation option for enterprises that need to take an alternative route in their digital transformation process. 

Looking for more transformation solutions? Learn more.

The COBOL maintenance experience is based on:

--> Visual Studio Code: a popular, modern, open source IDE that is developed by Microsoft and that can be used and extended for working with many different programming languages

--> CobolBridge: a set of components that enable:

  • Maintaining COBOL code inside Visual Studio Code: with all the expected intellisense + syntax-highlighting as expected by modern developers. This is called COBOL VSCode Plugin below.
  • On-the-fly transforming the COBOL code to Java/C# and then compiling the Java/C# code using CodeTurn/Raven.
  • Debugging the code is possible by running the JVM/CLR code and at same time stepping through the COBOL code in Visual Studio Code. This is referenced as the COBOL Debug Server below. The JVM/CLR code can be executed either locally or remotely.

--> CodeTurn: the exact same toolset used for automated COBOL to Java/C# transformation: the transformation tool and one COBOL Services support library.

Maintenance Stage

At maintenance time, COBOL sources can be edited inside Visual Studio Code: syntax highlighting, and error reporting are provided by a COBOL VSCode plugin. This plugin will start the ‘on-the-fly-transformation-and-compilation’ of these COBOL sources into JVM/CLR bytecode.

During the transformation, mapping files are generated so that at debug time, locations and expressions in the Java/C# code can be related to locations and expressions in the original COBOL code.

 

Aside from enabling this transformation and compilation flow from the Visual Studio Code IDE, it is also ensured that this can be done ‘in batch’, so that a DevOps pipeline can be setup – for example in Jenkins. The most important ‘extra’ in this regard is ensuring the mapping files are generated and bundled with the bytecode, so that debugging is possible.

Supported Features

  • Syntax highlighting
  • Jump from variable to definition (also inside copybooks) 
  • Jump from use of paragraph/section to definition
  • On-the-fly transformation and compilation
  • Jump from syntax error to place in source where it occurs
  • Auto-completion of variable and other names
  • See outline of source
  • Collapse sections and paragraphs

 

Debug Stage

At debug time, the COBOL VSCode Plugin can be configured to connect to a ‘Debug Server’: this is a separate component that supports both local and remote debugging.

The Debug Server is based on two well established protocols:

--> A Microsoft’s Debug Adaptor Protocol to communicate with VSCode

--> The Java Debug Interface to communicate with the Java virtual machine

The Debug Server acts as an intermediary between the running application (which has the application binary code and the COBOL services support library) and the Visual Studio Code IDE.

A user setting breakpoints or stepping through the COBOL code inside Visual Studio Code, implicitly requests the Debug Server to perform the equivalent operations in the running Java/.NET process and vice versa.

The Debug Server also reports back the current state of the application in terms of COBOL locations and expressions: the mapping files are used to establish this.

Supported Features
  • Set breakpoints (also in copybooks) 
  • Inspect the value of any COBOL variable
  • Run to next breakpoint, jump into/over paragraphs
  • Inspect the COBOL CALL / perform stack

 

Main benefits

Here are some of the solution’s main benefits:

  • COBOL developers only need to get trained in the new toolset; no need to learn Java or C# itself
  • Resulting application can benefit from many features that the Java/.NET ecosystem has to offer:
    • modern development tools,
    • lower costs (limited runtime license costs),
    • modernization and refactoring possibilities,
    • cloud ready to be deployed in Docker containers
    • The generated Java/C# code is perceived as very maintainable by original COBOL developers and maintainable by non-COBOL developers after adequate training. This is very important, since at any time in the future, one may decide to no longer maintain COBOL code. At that stage, no new migration project is needed, the developer can just start maintaining the generated Java/C# directly and continue to work.
    • The style of the resulting code can be chosen by an ever-growing list of transformation options/rules which are closer or further away from COBOL. This means that, at any time, one can choose one’s own style of transformation

 

Want to know more?

Contact our experts and get support for your migration project.

CONTACT US