Skip to main content

Leveraging Development Tools as Expert Systems to Retain Developer Expertise

How to leverage IBM Application Discovery and Delivery Intelligence (ADDI) and IBM Developer for z/OS (IDz) as Expert Systems

A person with glasses looking at a computer screen, which is reflected in the glasses.

A big challenge facing mainframe shops is the loss of valuable expertise as developers retire or move on to other jobs. Part of the solution has always been to provide modern development tools that attract young programmers. Being able to back fill retiring programmers is critical. But this approach looks at the problem purely as a head count issue. What is also critical is dealing with the reality that when you lose an experienced developer, you lose their expertise. While that may seem obvious this issue is rarely addressed because strategies for addressing it are rarely explored or implemented. In this article we want to change that. We want to explore ways that the expertise of your best developers can be retained in your development tools and made available to new programmers along with the rest of your mainframe shop. This means that it’s important to find ways that you can leverage your modern development tools as Expert Systems. It should also be pointed out that the concepts described here apply equally to the distributed side of an IT shop where the same challenges exist.  

The Concept of an Expert System

The term “Expert System” has been around for years and there are both simple and more complex definitions. Doing a Google search on the term “Expert System Definition” yields definitions that often merge some form of AI and data to produce intelligent or expert analysis of that data. While this is valuable, these techniques don’t always lend themselves to capturing the expertise of developers.

Older and simpler definitions did not reference artificial intelligence and focused more on individual expertise. This definition focuses on an Expert System as any system that can capture the expertise of experienced team members in a fashion that makes that expertise available to others. This more basic definition is what we will focus on when describing the leveraging of development tools as an Expert System. As examples, we will use the IBM Application Discovery and Delivery Intelligence (ADDI) and the IBM Developer for z/OS® (IDz) solutions to show how this can be accomplished. From these examples we hope you can then look at your own development tools with new eyes and ask yourself how they can be leveraged as Expert Systems.

The Challenge

While retaining the expertise of experienced developers is often a priority for IT shops, mainframe and distributed alike, the process for doing this can be haphazard if it exists at all. Experienced developers retire and new or less experienced developers must take up the task of maintaining the application base in a timely and quality fashion. Code must be enhanced and new code must be developed and these activities should follow accepted standards. Assisting new developers with the quality of their work and analyzing the health of an application code base are labor intensive activities that consume the time of your most experienced developers. There needs to be a better way.

In the following examples we will look at how modern development tools can capture, and then make available, the expertise of your best developers. It should also be noted that this expertise comes in two forms. The first is a technical knowledge of the development environment and coding languages. The second is an understanding of your application base, how it works, and the business logic involved.

Example 1: ADDI Coding Rules 

ADDI has the functionality to define coding rules and then apply those coding rules to one or multiple programs. The ability to apply coding rules that have been evaluated and defined by the most experienced developers will be an invaluable resource to new developers. The expertise embedded in the coding rules will remain long after those experienced developers have retired or moved on to other jobs.

This is what a Rules Based Analysis looks like in ADDI. This is just part of the report which shows the results of an analysis of a group of COBOL programs to determine if they adhere to the defined coding rules. As you can see from the report in Figure 1, below, the “DISPLAY variables used in PERFORM” had several failures while there were no violations of the “Files opened but never closed” and “Initialize of large records.”

Figure 1

Drilling down to line 187 of the COBOL program JKEMLIST shows the following code, as seen in Figure 2, below.

Figure 2

There are a variety of development tools that have these kinds of capabilities like the example shown in ADDI. They need to be leveraged so that you are capturing the expertise of your most experienced developers while making that expertise available to the development team.

Example 2: IDz Code Snippets 

Programmers learning a new language or learning to program for the first time often rely on the internet for coding examples. While this practice is simple and easy, it’s problematic when trying to maintain quality and consistency in a code base. Coding examples found on the internet may not represent the best coding practices. There could also be legal issues with using these examples in production code. Often these examples will not leverage the capabilities of the version of the programming language in use by your shop. If your shop is upgrading to the latest version of a programming language, it’s important to include a review of your coding samples to ensure that they remain current. 

As a new programmer, and even as a more experienced programmer, it would be nice to have access to some sort of library of “best practices” code samples approved by the most experienced developers on the team. These samples will help ensure that we are using techniques that meet the standards set by our team. The ability to leverage this expertise is key to maintaining a quality and consistent code base.

As an example, IDz has a feature called “Code Snippets.” These code snippets are examples of approved techniques to be used by developers to help maintain quality and consistency in application development. The screen shot in Figure 3, below, shows accessing a COBOL code snippet that compares the difference between date variables. Changes can be made to the snippet and variable values can be set before inserting the code into the COBOL program under development. This not only provides developers with quality examples, but it keeps them from searching the internet for examples which can lead to inefficient and inconsistent coding practices.

Figure 3

Example 3: ADDI Annotations

We’ve all seen situations where a government regulation goes into effect or there are new business challenges and the development team is rushing to determine what changes need to be made to what programs. Often this includes finding and consulting with team members who have done this before and know which programs need to be reviewed and modified. Sometimes those team members are on vacation, retired or haven’t made these types of changes in a while, leaving everyone scrambling. It would be nice if their expertise had been previously captured in the development tools so that everyone had access to this information. 

Development tools and source code repositories often have the concept of an annotation, which is the ability to attach a comment to an artifact. Annotations can and should contain information about the application base, which is useful to developers but also to project managers, architects, analysts and more. This information should be available in a searchable format without the requirement of accessing in-line documentation in the application source code. 

In this example we are working with a project defined in ADDI that contains COBOL programs, JCL and a variety of other artifacts. We’re looking at a challenge a bank might face when new regulations are enacted effecting how taxes are reported. In our fictitious bank, JKE Bank, we have a development process that includes creating annotations in ADDI with the appropriate keywords when important changes are made to our business logic. Below is a snippet from an ADDI search that shows us which annotations contain the key words “Regulation” or “TAX.” We can now see which programs and jobs contain this business logic. This expertise had been retained in ADDI and is now available to our development team.

Figure 4

Implementing the Process in Your IT Shop

So, how is this going to work in your IT shop? We would recommend three basic steps:
  1. Analyze your development tools to look for features that can capture the expertise of your best developers. Searchable external comments along with quality code samples are just a few of the features you could leverage in this process. Be creative. Think outside the box. Every shop has different tools with different capabilities.
  2. Leverage these features as part of the development process
  3. Create a process for transitioning experienced developers out of the team. When an experienced developer is leaving the team set up sessions where their expertise can be described and recorded in your development tools.
Now, when applications need to be enhanced due to changes in your business or regulatory environment you aren’t faced with finding “that developer” who knows what to do. New developers will have access to quality code samples and can check their work against team coding standards. It’s like having an experienced developer looking over their shoulder. You’ve leveraged your development tools as an Expert System.

Where Do You Go from Here? 

Envision where you want your mainframe development shop to be in a year, two years or five years. If you’re like many mainframe shops, you want to achieve your vision in part by providing an environment where modern tools are in use for development and analysis. You may envision a world where your mainframe shop shares common tools with your distributed shop. A world where the latest tools are attracting the best and brightest young developers. You should also be envisioning a world where your most experienced team members, the developers that were the original authors of many of your critical assets, are always with you as their expertise lives on in your development tools. You’ve created an Expert System that will benefit your team today and into the future.  
IBM Systems Webinar Icon

View upcoming and on-demand (IBM Z, IBM i, AIX, Power Systems) webinars.
Register now →