Enterprise Tech Journal Winter 2015-16 : Page 6
Ways to “Trick” Millennials Into Working on a Mainframe 7 By Glenn Everitt
7 Ways to “trick” Millennials into Working on a Mainframe
So,you did a survey and many of your mainframe programmers are going to retire in the next five years. Being the proactive IT leader you are, you made an earnest effort to hire people but you soon realized there are few Gen Y mainframe programmers. Then, you got a bit worried about the situation. You went to “Plan B” and hired smart millennials and got them working with your soon-to-be retired mainframe people. A couple of new problems surfaced and you ended up losing a couple of promising college graduates when they started to try to learn the mainframe tools. They’d come with enthusiasm for sure, but it was quickly dampened when they had to use a low-res terminal emulator to ISPF panels with bad fonts. They had expected great things from the systems that run the world and what they found was an inferior set of tools to program and control these systems that drive world economies. Having lost these hard-won new hires, you realized you needed a “Plan C”—and quickly.
Things have changed since the ’80s. You simply don’t have time for newbies to learn everything the way you used to—reading tens of reference manuals and being mentored for 10 years into the perfect enterprise software developer. How are you going to keep your new hires from going to other system platforms that are widely perceived as cooler than working on the mainframe?
What you need is a set of tools that make these new people productive in the maddeningly complex mainframe environment. The good news is millennials aren’t afraid of command lines and crazy command syntax and managing hundreds of servers. They do that with Linux images on Amazon Web Services. Some tasks are much easier and much faster using its sophisticated tools that provide immediate access to information needed for the work at hand. So, the question is, how do you “trick” these millennials to continue to work on the mainframe?
Make It Look Like Everything Else
First, we need to hide the mainframe connection inside the tools they are familiar with using. Don’t make them use some free 3270 emulator with an obscenely colored user interface. You can provide them a modern interface to the mainframe with multiple choices of Eclipse-based tools. These tools provide drag and drop and contextual online help. They also provide a sophisticated editor with code completion and other time-saving features. These types of tools are expected basics.
Let Them Own It
Next, let’s not make their first big project retrofitting some obscure financial rule into 7,000 COBOL programs. Let’s find a new piece of development, perhaps a batch program. Ownership is a powerful incentive, so let them own it. As our intrepid millennial mainframer works on his new batch program, we should again provide a modern interface to source code control management. Many mainframe software vendors provide Eclipse plugins to allow some basic code check-in/ check-out. These products could use improvements, but it is still better than forcing them to use an ISPF interface. Your new mainframer will adjust better to a rightclick check-out than to navigating through seven ISPF panels and then using wildcards to find needed files.
Give Instant Feedback
Once she has found the location for her project, let’s provide a basic working program template. We should make it easy to deploy the program into a test area, so she can experiment with the code quickly and get an understanding of how the pieces fit together. You probably created well-defined code templates that haven’t been looked at in a decade. It’s time to dust those off with a quick review to make sure they still meet your site’s coding standards and architecture criteria. Hand over this template and JCL in a form that can be compiled/linked and run and get out of the way. The millennial will figure how to write the business logic.
Easy on the JCL (and the Other Stuff)
Consider doing this batch program with the latest compiler and the highest architecture level your hardware supports and ensure compiler optimization is turned on. It’s an opportunity to discuss MIPS pricing, how optimization affects performance and the issues of debugging optimized code. It can also be a first step in their introduction to JCL and mainframe files. These are two items a millennial probably hasn’t seen before. Your millennial mainframer assumes that operating system can allocate a file, but he doesn’t know that mainframe operating systems have hundreds of file allocation variations. He also assumes the operating system is smart enough to find the resources to run his job. It’s probably best to point at your standard JCL and find a typical file allocation for his batch job and tell him this is configuration information similar to what he would have to provide to a webserver. A modern interface on JES can also eliminate questions of where did my program go?
Break It Down
Learning a large, complicated system all at once is time-consuming and frustrating. Why not provide tooling that allows ongoing discovery? Most green screen tools assume you know where everything is located. Eclipse-based tooling allows you to easily look through your systems and piece together the larger picture. Don’t point them at outdated system diagrams and 10-year-old unmaintained system documentation. Teach them to use tools that dynamically find the information and present it in a graphical view. Eclipse file explorers or CICS and IMS explorers provide a great way to become familiar with subsystems and what programs run on them.
Help Them Understand the Code
As they begin to work on large (sometimes giant) applications, provide them application analysis tools. These tools provide a faster road to understanding large systems, so they don’t have to look at thousands of lines of COBOL code to get an understanding of how the application flows and the data gets used. Runtime visualization is a great learning tool. The new developer can see programs starting, data sets being opened and closed, business logic functions being called, all without the time-consuming effort of finding the source files and trying to make sense of it. Access to application analysis tools will reduce the onboarding time for your new hires.
Automate, Automate, Automate
While you’re at it, provide automated deployment tools to reduce the manual steps of getting programs compiled, linked and added to modules in the correct test, integration and production systems. It will eliminate mistakes and drama for the new people. It will also help make all your developers more productive and, let’s face it, even experienced people make mistakes. The automation can hide the fact that many of the systems have name size limitation so one letter “naming conventions” don’t have to be remembered. A millennial using automated analysis tools, source code level debugger in Eclipse and automated deployment can be productive much sooner. Your new millennial programmer will start to show their more experienced colleagues how much more productive they can be.
You Can Do It!
There will be seasoned developers who will say things like, “Back in my day, we only programmed in Assembler because we wanted fast code. We didn’t need fancy tools; we knew where everything was.” This might have been true THEN, but your old Assembler code doesn’t take advantage of the great new instructions available on the mainframe. If you coded all those COBOL applications, of course, you know where they are and what they do. But those 30 programs grew into 300 programs over the years. The amount the new guy has to learn also grew 100 times and the older developer’s memory has probably faded a bit, so don’t rely on him to train the new guy.
As you hire your new millennials, take advantage of a critical opportunity to rethink the tooling that was “good enough” for the last 10 years. Smart millennials are more than capable of figuring out the mainframe. Providing modern tooling to make the job of learning vast systems easier is the least we can do. Let’s show the mainframe platform in the best light by showing that modern tooling can reduce the learning curve and improve programmer productivity by reducing the number of manual steps. Bits are bits, but how you work with them and the tools that help can make a world of difference in job satisfaction. Let’s build a mainframe workplace with excited millennial mainframers.
Glenn everitt joined Compuware as part of a start-up acquisition. He was the chief architect of the start-up’s core application. He has architected products that run on Mobile, Windows, Linux and Mainframe platforms. He is actively involved in technical due diligence of Compuware acquisition efforts. He is currently working with Product Management on product strategy and its technical feasibility.