Replacing Your Retiring RPG Developers Is Simpler Than You Think
How to recruit developers who can easily learn modern RPG—and help modernize the rest of your shop.
By Kristin Lewotsky08/01/2019
From their earliest incarnations, RPG and IBM i have been designed to simplify the development and execution of business applications. The names and even formats of the programming language and OS may have changed, but the duo has been fundamental to business operations for decades. Today, many of the programmers who wrote and maintained RPG applications for decades are nearing retirement. Enterprises find themselves searching for replacements in a shrinking talent pool—or at least that’s the perception. The reality is quite different.
In addition to students taking RPG courses at colleges and universities affiliated with the IBM Power Systems Academic Initiative, enterprises can draw from developers experienced in other languages. By looking for candidates with the right skill set (hint: not necessarily years of RPG/IBM i experience), organizations willing to invest a modest amount of time and effort can transform developers with a little non-RPG experience into skilled RPG developers—and in the process, transform their own RPG shops for the better.
Look for the Right Qualities
Probably the biggest problem organizations have when trying to recruit for RPG openings isn’t the lack of candidates with the necessary skill sets but a tendency to ask for the wrong skills to begin with. “When most RPG shops advertise for an opening, they’re looking for a person who really doesn’t exist, and even if that person did exist, they wouldn’t be able to afford them,” says Susan Gantner, partner with Partner 400, RPG training specialist, seasoned developer in multiple languages and IBM i evangelist.
Companies frequently ask for three to five years of RPG experience, when the candidate pool typically coalesces around two extremes: zero years of experience or 30. Hire a 30-year veteran to replace a retiring developer and the same problem arises a few years down the road.
The experience pitfall is just the start. Quite often, job openings are far too specific. Organizations want experience of particular business applications or even a certain change management system.
“It’s hard to convince, let’s say a manufacturing company, to hire somebody who’s got 15 years of medical or insurance background,” says Bob Langieri, president of Excel Technical Services. “A company has to be open to finding the right person, not just specific industry experience.”
“Companies should be looking for candidates with application development experience, particularly business application development,” says Gantner. “They need basic capabilities like good written and verbal communications skills, and the ability to work on a team as well as independently. Specify however many years you want in software development but not necessarily RPG or IBM i because that’s the part you can easily teach them. Today’s RPG is just another modern language. The hard part is finding a good developer who understands business applications and the importance of working with the business users to meet their needs.”
Modernize Your Shop
When Gantner talks of today’s RPG being “just another modern language,” she is referring to the latest incarnation of a language with a long history. RPG was originally a fixed-format language for which various attributes were required to be defined in specific columns with specific syntax. Code that wasn’t located in the correct column would trigger an error, which is a foreign concept to developers experienced in other languages.
In 1994, the RPG IV or Integrated Language Environment* (ILE) RPG version of the language allowed for some free-format expressions, but the code was still primarily fixed format in nature. Beginning in 2001, the logic portion of RPG programs could be written in free format, but declarations of data and procedures still required columnar code. That was a major step in making the RPG syntax more akin to that of modern languages.
The process continued until the 2012 release, when virtually all RPG code became free form. Show an application written in this “modern” RPG to a developer familiar with Java*, C, or even PHP and they will feel quite at home. That doesn’t mean that they won’t need some time and training to learn the language, but the process will be quite efficient.
Pave the Way for New Talent
The Value of RPG
RPG training specialist Susan Gantner describes training a team of six Java developers in RPG. After the opening session of the course, she left them with a homework assignment before returning the following month for the second session. When she returned, they sheepishly admitted that they hadn’t done the homework. Before she could respond, they explained why. They had been writing some pieces of an existing business application in Java. After the class, they converted some of that code from Java to RPG. “They had not only learned the basics of RPG in a week, they had learned that the power and simplicity of the language made it a better choice for some of the code they had written earlier in Java,” she says. “We couldn’t have been more delighted.”
The caveat to the above is that the RPG code needs to be free form. That is by no means a given. IBM has invested significant effort to continue to support earlier versions of RPG and IBM i. As a result, applications from the 1990s or even 1980s written in fixed-format RPG still run in enterprises around the globe. The columnar, fixed-format version of the language is far more confusing to the uninitiated and has a longer ramp-up time. This can add somewhat to the challenge, but Gantner suggests an effective strategy.
First, modernize the RPG code to whatever degree possible. This means at least converting it to completely free-form syntax. Modularizing large programs to enable code reuse and flexibility of UI is another step in code modernization. Yes, it involves a certain investment in time and effort, but the benefits are worthwhile in terms of both more efficient enhancement and maintenance of the code as well as staffing. Coding techniques have improved dramatically since the 1980s. Fixed-format RPG applications that required thousands of lines of code can be dramatically streamlined by refactoring to take advantage modern RPG language capabilities and modularization. Modernizing applications cleans up the deadwood while retaining the advantages of RPG and IBM i. Equally as important, modern code is easier to understand and maintain by both experienced RPGers and new generations of developers.
Automated tools exist to assist with this task. Of course, not all IT applications are suitable for updating. Some may be using proprietary code that IT shops can’t or don’t feel capable of modifying. Other organizations may find the sheer scope of the task to be off-putting. The benefits are worthwhile in terms of both operations and staffing. “I suggest getting as much of the code as feasible into at least the 2012 flavor of RPG,” says Gantner. “Then, you can bring in the new folks and tell them that it’s just another language. They can just start working on the code and taking the code refactoring to the next level.”
Most shops will have at least some residual fixed-format code, but that’s all right, she says. “Teach them the new stuff, get them hooked on the language because, based on my experience, they will really like IBM i and they’ll also like RPG.” (See “The Value of RPG,”.) Once they’re comfortable with free-form RPG, they can be exposed to the fixed-form applications, and probably make a simple transition. “At that point, most of them will probably just dive in and live with it like the rest of the programmers have,” she adds.
The process actually benefits all programmers in the organization. Some may have been anxious to modernize the code all along. Those who prefer fixed format can take responsibility for maintaining legacy applications. Modernization improves the quality of the software, makes the IT shop more responsive, and futureproofs the organization. This helps an organization manage retirement of other experienced RPG developers and lay a foundation for modern application extensions.
Techniques for training individuals with no previous experience in RPG can be roughly broken into four categories: sink or swim, self-training, mentoring, and organized training.
If formal training isn’t an option, a motivated student can couple sample applications with material for self-learning. When Calizo wanted to augment his initial training, he turned to the web. “I found plenty of articles and forums out there that usually had the same questions I had,” he says. “YouTube also came in handy, as I’m definitely more of a visual learner.”
Mentoring New RPG Developers
Any type of training is more effective if the student has additional guidance. Calizo took advantage of the opportunity to learn from expert colleagues. “They each have around 30 years of RPG experience,” he says. “I was (and still am) able to go to them for any questions I have on RPG and IBM i and they will assist me.I think it was crucial to have two great mentors by my side asI learned a language that was completely foreign to me.”
Langieri is a big fan of this approach—provided the company is committed to making resources available. “In order to take in an intern or a Java programmer and teach them RPG, you need to make sure that your RPG programmers aren’t so overloaded that they can’t spend time with the Java person,” he says.
The contact between mentor and mentee doesn’t just benefit the student. A developer experienced in another language or environment can teach an existing RPG programmer quite a lot. Their experience brings value to the RPG programmers at the same time new hires are busy learning the new language and platform.
The time investment doesn’t need to be large. “Have your staff do a weekly one-hour code review with both the senior members and the new hires,” says Langieri. “Everyone learns a little and it keeps everyone on the development side using the same techniques and styles, as well as building a standard for documentation.”
Sink or Swim
Invest in Training
In an era focused on keeping hands on the keyboard, neither IT shops nor developers invest enough time and money in the training required to keep their skills current, says Bob Langieri, president of Excel Technical Services. “If companies were more open to people learning, they’d have better programmers, better quality software, and it would be easier to attract people. There are various training or education events held around the country from POWERUp, hosted by COMMON, to System i Developer’s semi-annual RPG & DB2 Summit. Regional user group conferences also provide excellent skill refresh and quick-start learning on a budget.”
The training approach that delivers least consistent results is simply to set new developers loose on existing code to teach themselves. The effectiveness of this method is highly dependent on the experience of the developer and the quality of the code in question. Give an inexperienced programmer a 1980s application written in fixed-form RPG and they will simply learn to emulate bad habits. This technique is really only effective with high-quality applications as examples and should only be implemented with a mentor available for guidance and Q&A.
Before giving into the temptation of sink or swim, organizations should quantify the value to business operations of the applications in question—and cost of failure, or even delays. In the vast majority of cases, the numbers dwarf the cost of a training course or trip to a conference (see “Invest in Training”).
Lasting Business Value
RPG remains in widespread use for business applications for good reason. “When it comes to business applications, there is no language that can beat RPG in terms of the simplicity of running business applications without a lot of complexity, particularly data-intensive business applications,” says Gantner. With the right recruiting approach and a commitment to training, organizations can lure the talent that will enable them to reap the benefits of RPG for some time to come.
Kristin Lewotsky is a freelance technology writer based in Amherst, NH.