Imagine if you could manage mainframe processes with the same agility as the typical cloud environment, delivering a seamless, simple, and secure user experience. Turning that dream into reality would fundamentally redefine how enterprise development and operations professionals interact with and work on the mainframe.
Due to three driving factors, it is now mission-critical to empower the people at the center of the mainframe with a new set of tools to create a modern user experience:
- Businesses need to make mainframe development attractive and accessible for a new generation of developers. Businesses are experiencing a ‘double whammy’: experienced mainframe developers are retiring and the generation replacing them wants to ramp up quickly on the mainframe … without acquiring deep mainframe expertise. Consequently, there’s an urgent need for businesses to rethink application development for the mainframe.
- Mainframe needs to become part of the enterprise DevOps initiative. Line of business teams are increasingly adopting DevOps principles, but often struggle to integrate mainframe development into their existing delivery pipeline. This could make the mainframe a significant bottleneck. Businesses therefore need to revise their DevOps processes to support mainframe applications.
- Near ‘zero-touch’ and ‘zero-cost’ development and testing environments on the mainframe are increasingly in demand. The complexity of creating dev/test environments means they are often maintained long after they are needed, creating friction between the testing and development functions. Businesses need to address the time and resource demands associated with provisioning dev/test environments.
Let’s take a closer look at each of these factors and explore what the corresponding mainframe toolset looks like and the benefits these tools deliver.
Making Mainframe Development Attractive and Accessible
Many organizations are facing a generational shift in their workforce. Mainframe experts are retiring, ceding responsibility for mission-essential applications to a new generation of developers. These modern developers are a diverse group, with responsibilities ranging from specialized backend applications to web/mobile applications that touch the full technology stack. However, despite this diversity, they share a unifying lack of interest in becoming experts on mainframe and are not inclined to adopt the historical practices established by their predecessors.
Put simply, modern developers want to hit the ground running, applying their highly-coveted skillset without having to take on new competencies. For businesses to successfully hire and retain the best enterprise development talent in the market, it is imperative to step up and respond, enabling developers to use their preferred, best-in-class tools and, moreover, empowering them to treat the mainframe as any other development platform without having to learn its specificities.
What do modern developers want? In one word: a bridge. Developers need a bridge between the mainframe and the modern tools they are familiar with. This bridge must address multiple disciplines: source code editing, build tools, code testing and debugging, code quality, integration, and continuous delivery. Such a bridge would empower the modern developer to never deviate from their established best practices, from coding straight through to build, test, and deploy.
For example, implementing such a bridge would enable a developer to:
- Use popular IDEs like IntelliJ, lightweight text editors like Visual Studio Code/ Sublime with simple extensions to create or modify Java programs or traditional mainframe assets such as COBOL, PL/1, C++ programs, copybooks, Job Control Language (JCL), Procedures, control cards, etc.
- Manage mainframe source code with a Git user experience through integrations into mainframe SCM solutions.
- Orchestrate builds and write automated tests for mainframe development using prevalent build tools and testing frameworks.
- Interact through Command Line Interfaces (CLIs).
- Perform software change tasks on the mainframe without learning platform specificities such as ISPF.
A Day in the Life of a Typical Developer
Consider how such a bridge would work in a common development scenario (Figure 1). “Michelle,” a millennial developer, needs to make a change to the mainframe. Rather than learning the complexities of mainframe coding, she pulls up her favorite code editor, which has been bridged to the mainframe. She edits the source code and uses a modern build tool to run a local unit test. Once the code is perfected, she commits her code – again, using the tools she is most familiar with. The new code is deployed on the mainframe. To Michelle, it’s just another day of coding. The fact that the code was for the mainframe did not change her approach to her task at all.
Figure 1: Bridging the Mainframe and Modern Tools
One other aspect of this bridge is critical: it must not require movement or change by either of the shores it connects – mainframe or modern tools. In other words, the bridge must connect mainframe as it is and modern tools as they are. Otherwise, the adoption of such a bridge would require extensive work and therefore be self-defeating. The bridge must do all the heavy lifting. Only then will businesses unlock the full value of modern code development today and into the future.
Integrating Mainframe into the Enterprise DevOps Initiative
DevOps processes and mainframe applications have not historically “played nice” together. To integrate the mainframe into the enterprise DevOps initiative, therefore, “Ravi”, the DevOps architect, must be empowered with a new set of tools to help him succeed. Failure to do so will result in the mainframe being perceived as a bottleneck to achieving enterprise objectives.
The DevOps architect has a challenging role. DevOps architects must contend with the technical complexity of precisely orchestrating activities across platforms for effective multi-modal development, test, and delivery. They are responsible for the automation of the team’s release pipeline and for supporting an agile delivery methodology. They may have to integrate home-grown applications seamlessly with the mainframe.
To meet these challenges, the DevOps architect needs tools that will:
- Enable teams to build cross-product and cross-system solutions.
- Empower the user community to build their own custom automation and applications to match their specific needs.
- Enable continuous integration for a cross-platform application that may include, among other things, code managed by Git and transaction code managed by mainframe SCM solutions.
- Leverage versatile build automation tools like Gradle and Gulp.
- Embed mainframe automation scripts into popular continuous delivery software, including open source tools such as Jenkins and Travis.
But mainframe integration is not only about flexibility in tooling. DevOps architects also want a superior user interface (UI) through which to configure mainframe touchpoints. For example, the UI could simplify interactions through an abstracted Command Line Interface (CLI), removing the need to learn traditional UIs like TSO/ISPF.
With the flexibility to choose their preferred solutions and an easy-to-use UI for configuring mainframe interactions, DevOps architects can be empowered to easily build a DevOps toolchain that effectively integrates the mainframe into the enterprise DevOps pipeline.
Creating Zero-Touch and Zero-Cost Dev/Test Environments
A choice of tools and friendly UIs are critical to modernizing the mainframe experience, but more is required to resolve issues arising from developers not having adequate knowledge to access the mainframe. This is particularly true for application testing. Traditionally, provisioning a dev/test environment has been a labor-intensive task that can take months, with IT operations needing to oversee every step of the process.
Everyone loses with this approach. On the one hand, enterprise development teams cannot bring changes to market at the pace required to anticipate and meet escalating customer expectations. On the other hand, the exorbitant cost of provisioning and then maintaining these environments taxes an already shrinking IT budget. Altogether, the approach creates considerable friction between enterprise development and operations, inhibiting progress toward the unification that should characterize DevOps.
What is needed here is autonomy in the form of self-service provisioning. Self-service provisioning affords IT operations freedom from dedicating time and resources to supporting development teams. Instead, development teams can leverage self-service provisioning capabilities to create dev/test environments themselves and facilitate shift-left testing – all without generating an extra burden for IT Operations.
Such self-service provisioning would allow non-mainframe application developers to provision and interact with IBM middleware in a very user-friendly and script-friendly way. Developers would benefit from transparent interaction with the z/OS on which the service is provisioned. They would be able to interface with the mainframe through a modern, easy-to-use CLI, directly from their desktop.
The end result? By leveraging self-service provisioning, application delivery teams can:
- Eliminate bottlenecks: Development teams are further enabled to develop and deliver changes at the speed of business by leveraging self-service provisioning that is automated, standardized, and easy-to-use.
- Optimize resourcing: Freed from the need to support development with test environments, IT operations can focus time and resources on optimizing mainframe operations.
A Modern User Experience on the Mainframe
Building a bridge between the mainframe and modern tools does not force experienced mainframers into changing their preferred methods of working. The bridge simply becomes another option for how to interact with the mainframe. Mainframers can continue to use mainframe-specific tools and coding as much or as little as they like, while non-mainframers can interact effectively and efficiently with the mainframe via the tools and interfaces they are most comfortable with. Building a bridge, therefore, enables businesses to leverage their entire staff on the mainframe to the overall benefit of the business.
The promise of a modern user experience is a win/win for both business and DevOps teams and can help contribute to rapid time-to-value:
- Revenue is enhanced by the ability to innovate faster to enable a more frequent cadence of on-time releases.
- Costs are reduced by finding issues earlier in the cycle and eliminating manual activities.
- Development time is reduced by allowing removing obstacles to software innovation and improvement.
- Application innovation is accelerated by enabling teams to more effectively support Agile operations and DevOps initiatives.
By delivering a cloud-like experience for the mainframe, application delivery teams can make significant strides forward. Managers no longer have to recruit for mainframers with decades of experience, but can hire the next generation of developers. Barriers to innovation come down as developers and DevOps architects can respond with more agility to customer and business demands. Costs and cycle times decrease through self-service provisioning for mainframe assets. Developer and architect satisfaction and productivity skyrocket.
But, what will it take to build such a bridge? Watch this space.