SHARE Pittsburgh Best of the Best Session Winner, Dusty Rivers, director of z Systems Software: IMS & CICS at GT Software and SHARE program manager for IMGT, says implementing application programmable interfaces (APIs) at IMS installations can be as simple as knowing what issues you’ll run into before you run into them. His session, IMS APIs: You Don’t Know What You Don’t Know, explored some of the issues, solutions, and successes gained through the implementation of APIs. “I’ve worked with many of the largest global mainframe customers to develop their new services via APIs,” he explains. “In all of those cases, companies ran into a few issues with the unknown complexities of the mainframe applications that they did not expect.”

To avoid some of these issues, architects must first get to know their system’s applications. Some questions that should be asked beforehand include: how old are the backend applications of the mainframe; what technologies are being used; and is the application code structured or unstructured? Once those questions are answered, Rivers says architects then need to determine if any of the core applications started out as commercial offerings and which third-party components are embedded in the code. With these answers, architects can then explore the complexity of the code and data structure design. Architects must ensure that support teams fully understand the applications and how many coding “standards” have been used in the past.

The second step is to understand the mainframe’s applications and their API requirements. Rivers explains that most mainframe online applications were designed to interact with 3270 terminals (end user dialog). As a result, changing mainframe code to work better as an API can introduce more complex code that needs to be managed. Some companies could opt for “fine grain APIs, such as microservices, because they’re easier to build, but these APIs ultimately put more work onto the consumer,” he says. “Having a more intelligent API means less effort on the part of the API consumer processing logic.” Rivers advises that companies also ensure their integration technologies are transparent to backend systems, because it is sometimes hard to see what’s inside mainframe APIs.

Some of the issues architects will run into when developing APIs include:

1. Message switching and multiple program calls
2. Multiple input and output messages
3. Variable length, multi-part messages and different layouts
4. Complex COBOL (REDEFINES & OCCURS DEPENDING ON) and PL/I structures
5. C string null terminations
6. 3270 applications such as terminal emulators running screen macros
7. Complex CICS conversational transactions

In addition to these issues, integrating mainframe APIs into new DevOps solutions could require the use of more than one tool. Rivers says that IMS or CICS were usually the only tools needed before, but now may require tools like Github, Jenkins, .NET, Java, Node.js, Linux, JBOSS, Tomcat, MoogSoft, dynatrace, and urbancode.

For legacy environments, Rivers adds there is no coding required to integrate new APIs because they work with all components of IMS and CICS and any other mainframe environment. However, he cautions that legacy requirements will include the ability to create complex APIs by “orchestrating” multiple transactions in one API for a true business service and have mainframe applications act as both client and server in an API ecosystem. Additionally, some of the APIs can run off the mainframe (on Linux) if needed or on the mainframe to exploit the specialty engines, as well as run the APIs provider-developed in a container to exploit new trends.

Rivers says, “APIs are doable, but companies need to know their applications, know their systems’ complexities, and know where their systems are going in the future.” The mainframe can and has become a major API provider to the new API ecosystem, he adds. Once architects understand their current applications and their mainframe requirements for APIs, they are able to create APIs that can make it easier to develop a computer program by providing all the building blocks a programmer needs.