Spotlights

Mainframe applications influence business agility and revenue generation; organizations relying on them must deliver and maintain the highest quality and performance. But they face a quandary: a rapidly retiring pool of mainframe development expertise, combined with constant pressures to do more with less in terms of people, time, and money. Those pressures can lead to offshore outsourcing, which may lower costs, but can further aggravate problems tied to the lack of mainframe expertise.

To overcome these challenges, businesses using mainframes must attract top developers and empower them to maximize productivity while maintaining efficiencies gained over the years. This article examines how businesses can give their developers, particularly the newer generation, the tools they need to work successfully, while ensuring a smooth knowledge transfer and protecting existing mainframe investments. The key is to create a “bridge” between the less experienced and more experienced mainframe developers; the bridge can be a modernized, intuitive development environment that increases less experienced developers’ comfort level with the mainframe and shortens their learning curve. 

Background
The IBM mainframe was the first business computing platform to implement a comprehensive program development environment. Mainframe development tooling has evolved into a very sophisticated set of tools for the entire application lifecycle. These include solutions for source code analysis and editing; file and data management; interactive debugging and fault diagnosis; automated testing; and performance analysis. While subsequent platforms developed their own unique development environments that share much common functionality, the mainframe has continued on an independent path, albeit on an older, character-based user interface. While it has sophisticated development capabilities, the interface bears no similarity to the Integrated Development Environments (IDEs) found with non-mainframe systems. This disparity has given rise to mainframe development specialists: individuals adept at using mainframe productivity tools to write, test, change, support, and promote mainframe applications. These specialists have intimate knowledge of incredibly complex mainframe information systems, developed over decades and relied upon as the engines that drive the world’s largest organizations. Non-mainframe programmers have been reluctant to join these highly specialized mainframe ranks, precluding a clear path of succession.

According to the Pew Research Center (http://pewresearch.org/pubs/1834/baby-boomers-old-age-downbeat-pessimism), 10,000 baby boomers will be turning 65 every day over the next 19 years; this will no doubt have a significant effect on the number of mainframe programmers planning to leave their careers. With this skills shortage looming, businesses wishing to stay on the mainframe must make a concerted effort to attract the best and the brightest to fill this void. But the steep learning curve often associated with traditional, yet unfamiliar, mainframe tooling interfaces often discourages the next generation of developers, who may view mainframe specialization as a career-limiting move.

Bridging the Gap: Modern Development Environment Benefits
One way to overcome this challenge is to provide newer, less experienced mainframe developers with the technologies and tooling they need to bypass the steep learning curve and hit the ground running. Perhaps the biggest obstacle is the need to learn the details of the “green screen,” character-based mainframe development environment.
 
Modern user interfaces. A recent Eclipse Community Survey found that 60 percent of Java programmers identify Eclipse as their primary IDE. Overall, the new generation of mainframe developers and programmers isn’t familiar with the green screen application development interface. Many have never done anything in a character-based environment and view ISPF as antiquated, according to data from a recent SHARE conference. Given this lack of history with older mainframe applications and data, newer generations tend to perceive modernized software development environments with Graphical User Interfaces (GUIs) and functionalities such as point and click, as much easier to work with and more efficient.

By moving mainframe development tooling to a more modern framework based on industry standard platforms, newer mainframe developers can more quickly learn the mainframe by leveraging graphical, Windows-like interfaces that give them familiar functions (e.g., drag and drop vs. panel-to-panel navigation). This look and feel is familiar to most non-mainframe developers. While these developers still must learn mainframe programming languages, a modern interface eliminates the need for them to acquire the skillset required to work in the old environment.
 
Tightly integrated developer productivity tools. Mainframe developers have grown accustomed to using mature tooling that enables them to improve their productivity and ensure application quality. Today, modernized user interfaces for mature mainframe application development tools can exist in a common framework, side by side, with other non-mainframe tooling, so developers can flow seamlessly from task to task while working on a complex mix of applications across various platforms. By integrating these interfaces in an open development framework, a portfolio of feature-rich application development tools is available in a single, easily navigated environment. Combine this with the growing trend of increased terminal real estate as dual, large, flat-panel displays become more common, and a developer can make fast, smooth transitions from view to view. No longer is time wasted minimizing a window, then finding and maximizing a window for the next task.

All this helps less-experienced mainframe developers enhance their problem-solving capabilities, design and develop new application functionality faster, test it more efficiently, and move a higher quality product into production with less risk. However, users of the more traditional character-based interface can also benefit from this tightly integrated workflow; it’s a true “dual use” approach.

Consider a fairly common problem. An application fails with all the subsequent repercussions. The assigned programmer is expected to quickly determine the problem’s cause, address it, and get the corrected version of the application running. The steps involved are fairly straightforward and hardware/software-agnostic:
 
1. Notify the responsible programmer of the production issue.
2. Research the issue to determine the probable cause.
3. Set up the environment and prepare the data to test the issue.
4. Re-create the issue.
5. Modify application to address the issue.
6. Debug changes until they achieve the desired correction.
7. Scope changes to ensure they don’t have unintended repercussions.
8. Resolve the problem by implementing changes back into the production system.

By tightly integrating the tools to support these tasks, and allowing developers to access them via their interface of choice, both experienced and less experienced mainframe developers can solve problems quickly. Besides greater productivity and efficiency, improved collaboration between otherwise disparate teams and a smoother transfer of knowledge are important results.

Avoiding Some Pitfalls
Modern development environments address the training needs of the new workforce and reduce associated costs. However, some early adopters of modernized user interfaces have struggled with implementation. This has the potential to increase application risk, reduce productivity, cause project overruns, and inflate training costs.
  
For example, some modern development environment solutions require all of a businesses’ developers to move to a modernized environment. Forcing an experienced, green-screen proficient developer into a point-and-click environment could dramatically reduce productivity. In addition, some solutions require a per-seat license fee and an accompanying upgrade to each individual workstation. Often, the businesses using these solutions find themselves with a Total Cost of Ownership (TCO) that exceeds value delivered and with reduced productivity from their existing, already productive, mainframe development staff.
 
Conclusion 
Businesses using mainframes should employ a simple, pragmatic solution to support the migration of programming resources. Modern development environments should be affordable, simple to install, easy to use, and provide an opt-in choice that co-exists with its character-based, counterpart environment. By allowing developers to access application development toolsets via their interface of choice, both experienced and less experienced mainframe developers can be more productive and efficient, plus businesses benefit from improved collaboration between otherwise disparate teams and a smoother transfer of application knowledge.