Agile development -- linking pre- and post-release in an application's lifecycle -- rarely makes its way into the traditional mainframe workflow. And yet, agile DevOps on the mainframe can yield greater benefits than it does in scale-out Linux and Windows server environments.
There are four benefits to agile DevOps on the mainframe: Speed to deliver the application or upgrade, runtime-knowledge-infused software that adapts better to short- and long-term evolution of the application, better IT organization collaboration -- inside the mainframe group and across environments -- that produces higher-quality applications with less downtime, and better mainframe administrator productivity.
1. Speed to deliver
In mainframe IT, the word delivery has multiple meanings. Developers deliver code by putting it through a series of generic tests, then handing it over to the runtime specialists. IT administrators consider delivery synonymous with going live: actual, full-scale implementation of the code. Agile development only speeds up the tasks before that code handover; DevOps bridges the gap by setting up a full-lifecycle process that focuses on better feedback from the IT rollout team. Agile DevOps applies agile principles to administration, so that the developer and administrator speak the same language.
Administrative procedures on the mainframe are likely well-established, but many developers have more Linux and Windows expertise. Thus, agile mainframe DevOps has an unusually large gap in developers' understanding of the platform, making the predelivery code handover prone to delays. The same fate awaits major bug fixes.
Agile DevOps achieves "speed to deliver" by shrinking the gap between testing wrap-up and actual deployment, and by cutting the frequency and effort required for upgrades and bug fixes.
2. Runtime-knowledge-infused software
There are two areas in mainframe runtime software development where agile DevOps can improve knowledge and the quality of the program. First, many of the newer object-oriented operating systems, such as Linux, are more likely to run without stopping. Therefore, they are prone to problems, such as faulty garbage collection and failure to reorganize relational data stores.
Agile DevOps draws on the historical knowledge of the mainframe administrator to recognize patterns in the software platform, development and/or testing that cause these types of problems. The team can deploy code libraries and test suites with embedded pattern-prevention code.
The second area is in understanding the gaps in the test harness. Few -- if any -- of today's comprehensive test suites handle both non-mainframe and mainframe complex interactions (network, code layer and database) with equal skill. The mainframe often gets scanted.
Rather than expect the mainframe administrator to figure out where problems lie, agile DevOps aims to capture existing knowledge about mainframe complexities in the test harness or as code embedded in the application itself. This not only makes the developer's and tester's jobs easier, but it also makes the administrator's job easier down the road.
Simplifying tasks for the developer and administrator accomplishes "speed to deliver" and generates flexible software that doesn't require administrator intervention during upgrades.
3. Better collaboration for higher quality
Mainframe administrators and developers often have a large disconnect. While relations between the two might never be congenial, the developers' and administrators' pride in their "agility" tends to create a common framework that minimizes friction.
By setting up and effectively implementing an agile DevOps process, CIOs should see an unusually large improvement in code quality and leaner administration of less frequently problematic apps -- even if the CIO doesn't focus on speed to deliver or runtime knowledge infusion.
4. Better mainframe administrator productivity
It is a truism to say that mainframe (and non-mainframe) administrators typically fight fires. For the mainframe admin, much of the fire-fighting involves new Linux environments and interactions with outside environments across a network.
Agile DevOps improves this mainframe-admin paragon, and in the process improves mainframe administrator productivity. First, agile DevOps gives the administrator more time to fight fires by automating standard batching and Linux-related tasks. This ensures solutions will be longer-term and higher-quality, and therefore decreases the need to handle emergencies over time. Second, agile DevOps decreases the time required to coordinate with development in a bug fix when development has a testing tool or code library appropriate to rapid identification and fixing a runtime problem by embedding the administrator in an agile process with connections to developers.
Getting there from here
While IT is in the early stages of implementing agile DevOps, some best practices have emerged:
- Identify and acquire mainframe and cross-environment automated tools appropriate for the agile mainframe administrator.
- Create an informal or software-based collaborative process between the mainframe administrator and developers.
- Focus on cross-environment rather than mainframe-specific application lifecycle management. Runtime slowdowns and crashes frequently involve cross-environment interactions rather than just the mainframe itself (e.g., speed to deliver, runtime-knowledge-infused software, better IT organization collaboration and better administrator productivity).
About the author:
Wayne Kernochan is president of Infostructure Associates, an affiliate of Valley View Ventures. This document is the result of Infostructure Associates-sponsored research. Infostructure Associates believes that its findings are objective and represent the best analysis available at the time of publication.