DevOps has moved beyond being the latest, trendy buzzword to mainstream. Today, it receives attention from industry analysts, marketers, bloggers, software developers and, more importantly, IT departments in large and small enterprises. Why? DevOps helps businesses compete by delivering innovations to customers faster and more reliably. Learn how the mainframe can be part of the DevOps conversation.

Issue 1, 2018

What is DevOps and why should you care?

Occasionally, I am asked if DevOps is a tool that can be bought. If only it was that easy. DevOps is really about organizational change. It is the practice of Development and IT Operations working together through the entire software lifecycle, from design through the development process to production. This not only requires a change in behavior and culture but the implementation of processes and the use of a new toolchain to bring it all together.

The main goal of a DevOps approach is to develop and deploy innovation faster—to meet the needs of your customers or constituents. But speed cannot come at the price of quality.

As a leading industry analyst notes: “DevOps emphasizes collaboration, automation and integration of development and operations teams, resulting in more frequent releases at higher quality”. ¹

Figure 1 : The Benefits of DevOps

CIOs are keen to use DevOps in order to respond to Line of Business (LOB) requirements faster by leveraging agile development. When development is agile, small teams work interactively on tasks in iterative work cycles with focus on delivering value to customers. By taking down the walls of hierarchy, there is transparency between teams, ensuring better coordination. Harmonizing the change management and development processes also allows CIOs to better scale development teams.

Yes, you may say, "Our Java^® teams and new developers are using DevOps but we are the mainframe team so this isn’t relevant to us." I beg to differ. Mainframe teams can play an integral role in the DevOps processes of your organization. Don’t let your CIO overlook your team’s ability to participate.

Why is DevOps relevant for the mainframe?

A key feature of DevOps is continuous deployment—which means tests are automated and immediately deployed to production. Google^® and Amazon^® do this—they make changes to live apps at a rate of 20,000 deployments per day. It is estimated that “Amazon deploys every 11.6 seconds." ² They are the pioneers of DevOps and need the speed to meet the dynamic needs of their marketplace. The speed of change is breathtaking in this environment.

In the mainframe world, this breakneck speed of change is just not realistic. But this does not preclude mainframe teams from participating in DevOps. While mainframe developers don’t have a culture of implementing changes willy-nilly and certainly don’t throw out changes continuously, they can benefit from many of the principals of DevOps, such as repository-based development and Continuous Integration (CI). If mainframe teams can get to a state where they can deploy on a weekly basis using DevOps, this is a big advantage over the waterfall models, which take months and lock processes.

Repository-based development supports parallel development

As simple as it sounds, it is a big change in the mindset of mainframe developers to realize that a repository like Git takes the lead over source code. All changes are now committed to this repository and from there, distributed to the corresponding environments. Developers have to pull source code out of the repository, implement and change code on a local workspace, then execute and test in a private and isolated mode on a remote development environment. Using the Natural programming language as an example, the single source of truth is now the repository and no longer the FUSER. Development happens in an Eclipse™-based platform like NaturalONE. Private mode supports work performed in parallel by allowing developers to test and execute their implementation in isolation from each other. A source code repository supports “branching” in which multiple teams work on multiple branches of the code then merge the branches upon completion. In your typical mainframe environment today, without DevOps, you have to lock modules and no one else is able to make changes. Waiting for the unlock kills efficiency and productivity. By working on a repository in parallel, you are not blocked.

What happens next if all this code is developed in parallel conflicts with one another? Fortunately, at the end, it all gets merged with the help of the merge capabilities of the source code management system. After committing and pushing your changes, CI ensures your application can be built with your changes incorporated into the shared development environment.

CI ensures the application build is successful

“A cornerstone of DevOps is Continuous Integration (CI), a technique designed and named by Grady Booch that continually merges source code updates from all developers on a team into a shared mainline. This continual merging prevents a developer's local copy of a software project from drifting too far afield as new code is added by others, avoiding catastrophic merge conflicts. In practice, CI involves a centralized server that continually pulls in all new source code changes as developers commit them and build the software application from scratch, notifying the team of any failures in the process. If a failure is seen, the development team is expected to refocus and fix the build before making any additional code changes. While this may seem disruptive, in practice it focuses the development team on a singular stability metric: a working automated build of the software.” ³

Any modification is uploaded and compiled in an isolated private mode. Once a developer has finished the work on a feature, he makes the changes available to others by committing the changes to the repository. Through CI, the new changes are transferred from the repository to the central development environment. It ensures our application is built successfully and should run unit- tests to prove all functionality is still given.

Figure 2 : DevOps on the Mainframe with NaturalONE

Continuous testing is required for DevOps success

Faced with increasingly complex applications delivered at dramatically faster speed, software testers have the potential to be the bottleneck that determines if a DevOps initiative fails or succeeds. To implement full DevOps, the testing process must be automated and transformed to happen continuously. This should dramatically reduce the level of effort required for testing. Testing must also be collaborative to ensure quality while reducing the time it takes to deliver new features.

Fortunately, there are a number of tools available in the market that can help. Like Java developers, mainframe developers using Natural can also establish and automate unit tests using NaturalONE and CI tools such as Jenkins®. All modules can be continuously tested to ensure quality and even Natural programs can be fully tested using the newly available Natural screen-based tester. For Natural mainframe developers, NaturalONE tools like profiling and code coverage for runtime testing complement the testing process. These tools ensure that the performance of the components delivered meets the business requirements and the code coverage of your unit tests is high enough.

Project and change management must be collaborative

Last but not least, effective project and change management is a key component in setting up DevOps in your organization. It is good practice in DevOps that no development and no change should happen if it is not linked to a proper task in a project or change management tool. So even at the beginning of DevOps, project and change management stands and all activities should support an existing task. Every source code change and every build and deployment should be tracked and, of course, fully automated. This will give you full transparency into the whole development lifecycle of your organization.

For mainframe developers running mission-critical applications, the stakes are high. You need the right tools to effectively coordinate and govern your system's development lifecycle.

Fortunately, if you use an Eclipse-based platform like NaturalONE, there are many open-source and third-party tools that you can leverage to help manage your project. NaturalONE integrates with all tools with Eclipse plug-ins like Atlassian Jira® and Redmine, an open-source tool.

Benefits of DevOps for the mainframe

From the CIO to the application developer, implementing DevOps means delivering better code, faster and more efficiently. Productivity is improved by automating processes and leveraging Eclipse and repository-based tools for parallel development.

Transparency is also greatly improved with a change management record that contains a history of all changes, version comparison and the ability to roll back to a previous version. With CI, test efforts are reduced while quality of deployment is improved.

One of the most empowering reasons CIOs will want to pursue DevOps is that it will help reduce the risk of business disruption due to the retirement of skilled workers—the generational change in workforce. This is particularly true, especially in the case of IT departments that still use Natural on the mainframe.

NaturalONE is the recommended development environment for Natural because it is fully integrated with the DevOps tool chain familiar to Java developers who will also appreciate

NaturalONE’s familiar Graphical User Interface (GUI) and wizards.

Because NaturalONE is Eclipse-based, you can standardize on a single platform across all program languages. You can efficiently cross-train personnel to deploy resources where they’re most needed—and at a moment’s notice. You’ll find it easier to recruit new programmers who will appreciate the collaborative DevOps support of NaturalONE for agile development and CI.

It is also interesting to mention that Natural applications running on a mainframe can very successfully run on open systems platforms as well. In fact, about the half of Natural applications operating worldwide are running on Linux®, UNIX® or Windows® (LUW). If your company is thinking about rehosting Natural applications to Linux, for example, your implemented DevOps approach can be fully applied the same way in your new open systems environment. It can even be a valuable first step when heading in this direction.

Jump start DevOps for your mainframe with NaturalONE

If you run Natural on a mainframe, I strongly encourage you to give NaturalONE a try. NaturalONE embraces the DevOps approach to development, enabling you to develop new applications and modernize existing Natural applications— faster—to meet changing business requirements and reduce application development costs.

NaturalONE operates in Linux or Windows and, because it is based on Eclipse, easily integrates with multiple Eclipse-based tools. Since work can be executed from one platform without having to open accompanying applications on their base platform, developers of Natural as well as Java or COBOL can efficiently collaborate and work on multiple platforms using a range of developer productivity tools from a single interface. NaturalONE is well-suited for developing applications to run natively on the mainframe, Linux, UNIX and Windows.

NaturalONE can accelerate delivery of new applications with automatic, interactive testing and debugging tools. Open-source versioning tools allow for team development so developers can write, test and execute programs independently while sharing the source code of the project in a team repository. Like Java developers, mainframe developers can establish and automate unit tests using open-source tools such as Jenkins. NaturalONE tools, like profiling for runtime testing, complement the testing process and ensure that the performance of the components delivered meet the business requirements.

From NaturalONE, you can use Construct, EntireX, Predict and many other tools by remotely connecting to your mainframe or LUW environment. For example, conduct Predict data dictionary maintenance and browse data using the integrated data browser for Natural Data Definition Modules.

Try NaturalONE for free at www.NaturalONE.com

Bring your mainframe into the DevOps conversation by leveraging NaturalONE. This Eclipse-based Integrated Development Environment (IDE) lets developers code, test and maintain applications, expose Natural objects as services, create Rich Internet Applications (RIAs) and web interfaces, and manage the complete DevOps lifecycle from one environment so you can modernize and deploy new applications more quickly with better quality to immediately satisfy your customers.

About the author

Zvonimir Ivanetic is a Senior Adabas & Natural Customer Success Architect at Software AG. He has been with Software AG for more than 10 years, working as a consultant on the integration and modernization of Adabas & Natural applications and the development of distributed, scalable web applications. With the introduction of the Adabas & Natural 2050+ Agenda, Zvonimir joined the global core team as an architect, supporting all customers in transforming to a digital architecture, optimizing their infrastructure and bringing innovation to their valuable Adabas & Natural applications.

About Adabas & Natural 2050+

Countless organizations rely on the Adabas & Natural platform for their mission- and business-critical applications. With the Adabas & Natural 2050+ Agenda, Software AG fully supports customers in harnessing the innovation potential provided by digitalization. From skills to connectivity, to DevOps development and cost-efficient platforms, Software AG is leading the way for the next generation.

Learn more at http://2050.softwareag.com

1. A CIO's Guide to DevOps, On-Demand Video - Watch Anytime, Anywhere. Retrieved from https://www.gartner.com/webinar/3165618

2. Hacker News. Retrieved from https://news.ycombinator.com/item?id=2971521. Lawton, George (2013, Sep 5). How Amazon Made the Leap to a DevOps Culture. Retrieved from http://servicevirtualization.com/how-amazon-made-the-leap-to-a-devops-culture/

3. Cois, Aaron (2015, Jan 26). Continuous Integration in DevOps. Retrieved from https://insights.sei.cmu.edu/devops/2015/01/continuous-integration-in-devops-1.html