Tag: z/OS

  • Modernize Without Disruption

    Modernize Without Disruption

    How to modernize without disruption.

    Through recessions, geopolitical shifts, pandemics and threats to global security, IBM® Z® has proven to be the most reliable, high-performing and secure platform in the industry. It’s time to expose the flexibility, agility and efficiency to provide an open and inclusive infrastructure that supports shifting business models and delivers strategic value.

    With Rocket modernization solutions, you can create an innovation layer that securely extends IBM Z capabilities with familiar software that today’s most innovative programmers use to deliver the modern and intuitive experiences customers demand. Get more from your legacy systems so you can create legendary, real-world outcomes for your customers.

    Reinvigorate your traditional infrastructure.

    Enabled with the right tools and technologies, organizations can modernize without disruption. Rocket Software can help you meet changing market demands with software solutions to drive value from your existing investments.

    Expand your talent pool to attract today’s most innovative programmers.

    • Rocket® LegaSuite® and Rocket® API – No-code modernization tools to deliver modern, intuitive user experiences that increase productivity and customer satisfaction.
    • Rocket® Open AppDev for z/OS® – With 1-click porting, give your developers their preferred open software through a system that combines the high security and support IBM Z customers demand with an easy user experience.

    Bring modern DevOps to your traditional systems securely with the familiar tools and intuitive experiences users demand.

    • Rocket® Aldon® – IBM® i ALM and DevOps platform allows your developers to work with the tools and environments they expect to develop innovative applications, while providing the process management and compliance reporting needed for today’s businesses.

    Support remote working by quickly and seamlessly adapting call center and service operations.

    • Rocket® Terminal Emulator® – Anytime, anywhere remote terminal emulation for your critical applications that delivers a lower total cost of ownership while improving the user experience.

    To read more, please visit: Modernize Without Disruption

  • Open Mainframe Virtual Summit: Adding Value to the Mainframe

    Open Mainframe Virtual Summit: Adding Value to the Mainframe

    While many predicted mainframes would eventually become obsolete, they continue to be prevalent in the corporate world. Mainframes are still in high demand, and the mainframe market is likely to grow over the next few years as business and IT leaders validate its enduring role in their hybrid strategies. Mainframes are rapidly evolving to meet the demands of today’s changing technology and business environments. How can we leverage the mainframe for reliability, availability and security? How does open source fit in with the mission-critical workloads that only a mainframe can drive?

    At the Open Mainframe Virtual Summit, taking place on Feb. 11, top industry leaders will come together to discuss all open source projects and technologies impacting the mainframe.

    Open Mainframe is a free virtual event featuring a conference lobby, presentation theater, expo hall and more. Attendees will be able to interact with sponsors and like-minded individuals who are passionate about the mainframe industry, watch videos and download information.

    Open Mainframe Virtual Summit features an exceptional lineup of industry leaders, including:

    • Abubakar Siddiq Ango, Developer Evangelism Program Manager at GitLab
    • Anna Murray, Senior Product Manager at ASG Technologies
    • Bob Miller, Solution Architect and Legacy Transformation Lead, IBM Alliance at Deloitte Consulting LLP
    • Gatien Dupre, IBM Z DevOps Offering Manager at IBM
    • Girish Wani, Agile Product Owner at Swedbank
    • Kristaps Duburs, Software Engineer at Swedbank
    • Maneesh Goyal, Offering Management Leader at IBM
    • Mark Howell, DevOps Centre of Excellence Lead at Lloyd’s Banking Group
    • Mathieu Dalbin, DevOps Transformation Specialist at IBM
    • Matthew Cousens, IBM Z and LinuxONE Developer Advocate at IBM
    • Michael Bauer, Zowe CLI Squad Leader at Broadcom
    • Mürsel Taşgın, Mainframe Systems Manager at Credit Bureau of Turkey
    • Nathan Cassata, IBM Z DevOps Testing Lead at IBM
    • Patrick Wawrzoszek, Programmer Analyst Advisory at Scotiabank
    • Peter Haumer, Senior Software Engineer, IBM Z DevOps Intelligence at IBM
    • Rajesh Murugan, Software Engineer at Swedbank
    • Rosalind Radcliffe, Distinguished Engineer at IBM
    • Rose Sakach, Zowe Onboarding Leader at Broadcom
    • Seamus Hayes, Software Engineer at Broadcom
    • Terri Cobb, Vice President, Alliances Relationships at Deloitte Consulting LLP
    • Umut Arslan, Unit Manager at Garanti BBVA Technology
    • Vaughn Marshall, Senior Principal Product Manager at Broadcom
    • William Alexander, Senior Software Engineer at IBM

    The breakout sessions will cover a wide range of topics relevant to the open source and mainframe communities—the latest in IBM Z, DevOps, LinuxONE, cloud, analytics, open source and more. Speakers will discuss:

    • The growing usage of mainframe computing
    • How to build and debug mainframe application code
    • The biggest business challenges of mainframe modernization
    • The benefits of using open source tools such as Zowe, Git, Eclipse and VSCode with IBM Wazi Developer and IBM Z Open Editor to deliver continuous integration on IBM Z
    • How IBM Z DevOps testing solutions can improve your testing capabilities and enable your CI/CD pipeline
    • And more

    To check out the full agenda and to register, please visit the Open Mainframe website.

  • Open Source and the Mainframe with Rocket Software

    Open Source and the Mainframe with Rocket Software

    Open source enables developers to quickly create and deploy containers and business services across public and private infrastructures. Open source tools allow DevOps teams to harness the power of the mainframe.

    In this TechStrong TV interview, Tim Willging, chief architect and strategist, and Peter Fandel, mainframe open source evangelist at Rocket Software, join Mitch Ashley to discuss advancements in the use of open source software with mainframe apps and tools. Tim and Peter challenge some long-held beliefs around mainframes, open source software and the increasing role open source is playing today.

    Rocket Software is a global software development firm that offers enterprise products and services.

    The video interview is immediately below, followed by the transcript of the conversation. Enjoy!

    Transcript

    Mitch Ashley: Hi everyone, I’m very pleased to be joined by a couple of great gentlemen here to talk about some interesting open source, security, mainframe, DevOps, all kinds of good things. So I’m pleased to be joined by Tim Willging who is chief architect and strategist for the mainframe business unit with Rocket Software and Peter Fandel, senior director of product manager mainframe open source. Welcome, guys.

    Tim Willging: Hello, thank you.

    Peter Fandel: Hello.

    Ashley: I think I might have said your name incorrectly, Tim. Is it Willging? I don’t know if I said that right. 

    Willging: That’s correct. That’s fine. 

    Ashley: Okay, good. Would you start? I’ll have you both introduce yourselves. Maybe you can also introduce the company, Tim, and then we’ll have Peter do the same?

    Willging: Sure. Yeah, I’m Tim Willging. As Mitch mentioned, I’m the chief architect and strategist for the mainframe business unit at Rocket. I’ve been with Rocket about 15 years and spent the majority of my career developing commercial solutions for the mainframe and mostly around database tools, DB2 tools. Rocket Software has been in existence for 25-plus years and is a privately held company and specifically we do software that’s not just on the mainframe but let me talk mostly about the mainframe software.

    Rocket has a development partnership with IBM and many of the solutions we develop are IBM branded; but we also have many things we’re doing Rocket direct; and open source, particularly the subject of this call, is one of those things that we also sell direct or partnership with companies direct to provide that open source. So Rocket has a long history with the mainframe and we believe in its future and in its sort of importance in the computing divisions across many of the largest companies of the world. 

    Ashley: Excellent. Great. Peter, if you would introduce yourself.

    Fandel: Sure. Peter Fandel, again. I’ve been at Rocket for 19 years. The great majority of those years in engineering management, and I took over management of the open source porting team about, four or five years ago and transitioned to product management about a year ago. And I manage both the open source porting portfolio as well as the Zowe portfolio, and both of those portfolios are critical components to the modernization story for the mainframe in large part because of the huge amounts of open source that are out there that you can _____ can get them running well on the OS as well as attracting talent, the next generation of developers. So that’s really our focus area for open source.

    Ashley: Excellent. You know, maybe you ought to start – and I started my career in the mainframe, too, and so I understand, kind of get where you’re all coming from in the market. There’s a lot of built up beliefs about mainframes and applications and whether you should think about porting or not or, you know, replatform them, leave them alone. Probably like you, I’ve learned it’s very costly and also fraught with danger to just go rebuilding applications, you know, because you think you want them on a different platform. You have to have a really good reason. But open source is actually a really important part of the mainframe ecosystem. I think maybe folks don’t really realize how important it is. How would you guys kind of set that up to give people an idea for the role that open source is playing in the mainframe environment today?

    Willging: Well, I’d start off by saying open source is incredibly important part of IT computing. I mean it’s something early career professionals are learning. It’s a huge way companies are running their business today and rather than writing things from scratch, many are starting with open source and then augmenting or augmenting existing systems with open source to modernize that open source because of its collaborative nature, how different companies and individuals contribute to that open source based on the needs of the industry. You really can’t separate the needs of our organizations that are running mainframes from that open source. Open source is a critical component of running your compute division. So without it, I think the mainframe would be, you know, would have a big missing part in what companies need to run their business today. 

    Fandel: I think also there’s a huge cost savings associated with that because you take any recent graduate and even not-so-recent graduate of any comp sci program and you ask them to start developing applications, they’re going to expect to build those applications on open source building blocks. And if they’re not there, your cost goes way, way up. As well, another area where open source is a must have is DevOps where if you want to – do you want to have a different DevOps tool chain for the mainframe than the rest of your organization or do you want to unify that? And if you’re going to unify it, it’s got to be open source based.

    Ashley: It’s a massive source of innovation and I don’t know if we’re here yet, but if we aren’t, we’re quickly reaching a point where you can’t operate a company, a software team without open source software. And if you aren’t using it, I can promise you your competitors are. So take advantage of it, right? Well, let’s talk a little bit about I know Zowe is of course a big important part of your strategy. Break it down for us. Go into a little bit more detail about where the places, roles that open source does play a role in the software development process and operational systems of mainframes, kind of paint that picture for our folks, our listeners.

    Willging: I think there are a lot of different ways it plugs in, but the one that I hear most of the companies I talk to is precisely what Peter just said. You know, the mainframe through many years of existence has been very waterfall-ish I’ve heard some companies because of the reliability. It’s the security, the maintainability of the mainframe that there’s a process which changes are rolled out in large batches. As companies modernize the mainframe and they start to add components to those mainframe applications that are off the mainframe, like in the hybrid cloud or have a web frontend or a mobile app frontend to a backend service or application that’s running on the mainframe, they want to be able to build, test, deploy the components of that application that go across the mainframe and those different computing platforms in the same manner.

    And to have tools, pipeline building tools, pipeline organization tools that have tools that build these environments, run the tests, destroy these environments, they need those open source tools to run on the mainframe to be able to drive those processes in a unified manner across all the different components of that application. So many companies today are just starting – you know, mainframe companies are starting on this journey. Many of them are hand rolling over the years have hand rolled sort of tools to try to have them plugged in, but that can get expensive as we’re talking about. So to get that open source running on the mainframe it’s important for them to be able to deploy those DevOps principles and practices in that application management lifecycle process. 

    Fandel: I would –

    Ashley: Very much so. Of course there’s also more with that too. Go ahead. I’m sorry, go ahead, Peter. 

    Fandel: I was going to build on what Tim said by introducing a really important distinction and that is that there is three very different ways you can get open source onto the mainframe. Most of the open source we’re talking about is units based. And you can do it by a Linux on Z, you can do it by a zCX Docker container or you can do it by UNIX System Services. And it used to be that the low cost way of doing that was Linux on Z and now more recently zCX because the porting is not much work to do because it’s all automated just port to the hardware which is done by compiles on those systems.

    But doing it on UNIX System Services is a lot more time consuming if you do it manually. But the advantage if you do port well on UNIX System Services is you’re close to the data. I mean if you’re running open source on Linux on Z or on zCX, it’s akin to running it on another machine on the network. You don’t have direct access to the data. Everything has to pass through TCP/IP. But UNIX System Services is part of z/OS and so you have direct access to all of the important data in your organization that MVS data. And that’s a key distinction. Where Rocket plays is open source on UNIX System Services on z/OS. So we are close to where the data is and we have solved the problem of high cost of porting through this GCC/GLIBC technology where we essentially automate the port of open source by simply compiling and linking in GCC and it injects the z/OS specific changes directly into the binary output of the build.

    Ashley: Talk about that process. Is that something that you’ve been doing a while? Of course going and changing binaries, most folks probably don’t do that as a natural first thought. But it does sound like a pretty straightforward way of minimizing the steps that you have to go through to get to begin using this. You can actually do it ____.

    Fandel: Yeah, it’s just we’ve been working on this GCC/GLIBC port in this manner for over two years, and it’s just coming to fruition now where in first quarter we will be releasing new versions of several of our ports that are not ported by hand. They are ported simply by building them with GCC, and we hope to have transitioned our entire portfolio by the end of 2021 to be built in this manner. And that means we no longer have to modify the source code because upstreaming is no longer a question, an issue. It means that we can turn around security vulnerability fixes much, much faster than we could otherwise.

    Ashley: I don’t mean this in a hyperbolic way or kind of playing up to you in any way, but that kind of an approach can be a pretty big game changer because you’re really asking people, it’s a low lift instead of a heavy lift to port if you will. 

    Fandel: Yeah.

    Willging: I’ve talked to many through the z/OS community who believe that due to the effort of going through these ports in the past, they felt that a better strategy was to run your open source close the mainframe – I say close with parentheses – or on a partition on the mainframe that’s running zLinux because the porting effort to get open source running on zLinux is minimal. And so they felt that the version currency, the security fix as Peter said, and the breadth of the packages available, open source source packages available on z/OS proper would always be behind. So they felt that was a better strategy to run it on zLinux.

    We don’t believe that at Rocket. We believe, as Peter said, that there are technical advantages to running that open source both from a DevOps standpoint but even more so from somebody who is looking to augment a legacy application say via some Python library that they’re looking to deploy where they’ve found some open source with a particular function. Running that Python on z/OS and accessing the data directly in concert with the legacy application that’s running or via some subfunction in that modernization effort is vastly different than running that Python in zLinux or on a machine off-platform and reaching into the data. The latency of what you can do, trying to embed that open source sort of in transaction, in the code in transaction becomes much more difficult to do. So we feel that Z customers as they’re looking to modernize will benefit greatly from opensource running on Z proper.

    Ashley: And as I understand, I think as you were describing it Peter, really you are talking about that compile process, right? That’s where you’re introducing GCC/GLIBC libraries. So that’s where this process is happening, changing things in a binary to adapt it to be able to use open source. Is that pretty much it or what else do you have to do to verify or test it or what are folks going to want to go through as they start to introduce this into the process?

    Fandel: Once we build it, we obviously have to run it through the test suites and we have two forms of testing. We have the built-in test suites that most open source products come with. I mean if you go to Git or Python and you download the source code from the community, it will be the product plus a huge volume of test code, self-test code. And so we execute that test code to make sure that it performs with the same results as on a test UNIX System. I think we used Ubuntu as the comparison and we compare the results. And if there’s any divergence on z/OS, then we inspect those divergences.

    And then in addition to that, we have a series of tests that test the z/OS specific capabilities that you want in open source. That’s mostly relating to the ASCII/EBCDIC conversion because z/OS and including UNIX System Service assumes EBCDIC is the default. Most of the data that you’re dealing with is in EBCDIC. And so our philosophy in porting on UNIX System Services, ASCII is the default internally. We compile with ASCII. Communication between open source packages and programs is in ASCII. But when you reach to the operating system, that’s where the conversion has to take place. So we have extra test suites for all of our ports that make sure the ASCII/EBCDIC conversion is taking place correctly both in file IO and pipes. So that adds to our testing process. So it’s not just build it and ship it. We do thoroughly test as well. 

    Ashley: That’s great. I’m glad you explained that too because there certainly are some fundamental differences in the operating system and environments down to the characters that –

    Fandel: Sure. 

    Ashley: – that we’re using. How about are there any kinds of applications that are more easier to port this way? That’s not the right way to say it. It’s not porting it but, you know, understand starting to use open source this way or others that maybe are a little more challenging, you might want to wait to take on that kind of an app? How would you recommend people get started?

    Fandel: Well, I mean we found that the porting a language is the most challenging because it just dips into every aspect of the operating system. So our conversion of the Python and Perl ports will be the last ones we release at the end of 2021. Our Python and Perl today are still, the ones we’re releasing are based on manual porting efforts. 

    Ashley: Okay, good. Any thoughts on that, too, Tim?

    Willging: I thought your question originally was like talking about a customer application they were looking to augment and add open source to what might be easier.

    Ashley: I would like to go there, too. That actually was my – but I’m glad you answered it the way you did, Peter. I’m curious from a customer perspective data intensive, things that are ultra-high security, high volume, lots of parameters can go into deciding what kind of an application you might use first to go down this path. Any thoughts on what you’d recommend to look at, to pick what app you might try this with?

    Willging: I mean there are a lot of mainframe applications that leverage CICS for online transaction processing and CICS is a great environment to deploy opensource. It’s been very forward thinking in its development to take and say a CICS application that’s written in COBOL and say you wanted to augment that via some modules that are written in open source language. That’s very possible and to make that communication really between the first thing you think about is there a runtime environment that’s involved, how do I want to lower that runtime environment so it doesn’t load every time that transaction is moving or it’s moving from the legacy code to the modern language?

    If there’s not, if it’s just a binary without a runtime environment, then you don’t have those types of concerns. So thinking about that and thinking through how you’re laying that out from an architectural standpoint and making sure you think through that. The speed of transition between legacy and open source language environments, that’s probably the biggest concern depending on what you’d like to do. But many companies have successfully done this and gone off and said, okay, we don’t want to necessarily go and rewrite my 30 million lines of COBOL. 

    Ashley: In a billing system probably not where I would start. 

    Willging: But there’s a new function we would like to add that potentially goes and augments via reaching to another system where customer data is available that you certainly can do that and many companies have done that successfully. Again, leveraging more modern languages and having that available for that augmentation is much cheaper, much less risk than is involved in a total rewrite and a re-platform which is again even then much of your language that you’ve written or much of what you’ve written won’t even necessarily run on a new system in the cloud. So replatforming is also very expensive or very risky depending on, again, the number of lines of code.

    Anyway, I probably went too far there but that’s sort of how I think about it from an online transaction standpoint. But a batch, different again, that you might just have some data that you want to reprocess and write a new output from that batch and augmenting there with open source is much easier because, again depending on the language can it run in batch, does it require to be hosted within a web server? But even then you can still have a batch process that alerts a web server to now go read this files so you can embed your open source within a say WebSphere Liberty or some web server that can go and even augment batch processes that way. It’s really getting the right architecture down first to say how you want to do that. 

    Fandel: Another area is data science and machine learning. You have for the past 20 years or so you’ve had academics and scientists and corporate engineers developing machine learning extensions, data science extensions, and they haven’t been writing those extensions in COBOL. They’ve been writing it in Python. And so that’s the go-to language for data science. 

    Ashley: It does give you access to a lot of new innovation just because of the language as well as the platform –

    Fandel: Exactly.

    Ashley: – and software stack differences. Two other areas I’d like to explore in our kind of time remaining, you mentioned DevOps and the role that open source plays in this. How does it help facilitate moving a mainframe application or developing a mainframe application now into more of a DevOps fashion? Are there some things inherent about because it is, you know, libraries that have a compile time process and there’s other tools? There’s Zowe and things like that can help you with interfaces and tool chains, workflows, things like that. What are your thoughts on that topic?

    Willging: Go ahead, Peter, you start. 

    Fandel: Well, I was just going to say that Git, since we release Git I think it’s three years now for z/OS, I think it was our number one download within 30 days of release. Everybody in the world is using Git now –

    Ashley: It starts with Git, doesn’t it?

    Fandel: – or Source Code Control. And so it, like I said before, just enables you to have a unified DevOps pipeline and that’s just huge. 

    Willging: Yeah. I mean to add to that, to have all of your source code in Git and then kick off a build process but then thinking of the mainframe and some of its legacy components like the parts of an application that help that make up the database. You know DB2 is very big on the mainframe. DB2 for Z. So to say that you can take those parts of the application touch the tables or smooth the tables in DB2 and extract those and then store those in a source code management repository because in DevOps you really want to store everything as code and represent everything in code so changes can be tracked over time. So taking open sourced, taking some even commercial tooling, taking some open source scripting languages, opensource to allow you to interact with a DevOps pipeline that’s running off the mainframe that’s driving the build and reaching in. You know, DevOps is really, again, not a product. It’s a culture and it’s a –

    Ashley: It’s a process. It’s a way of creating software, right?

    Willging: And so to build that DevOps pipeline using those tools but then have the tools – the DevOps tooling and scripting and running on the mainframe to be able to interact with the mainframe sometimes is a combination of open source, purchased tooling, and then hand rolling the pieces in between to fit your company’s needs. That’s really not possible. Again having a Git client for the mainframe and a lot of the other tools there are really important for that process. 

    Ashley: I’m curious about the security side of this. You know, a lot of application of air gap requirements things like that or the frequency or timeliness of security fixes. I don’t know if there’s a lot of difference between mainframe environments versus open source. That tends to happen of course more transparently. Maybe what are some of the advantages, pros and cons from a security standpoint of taking this approach?

    Fandel: Yeah, I’m glad you mentioned that because that’s one of the major changes that we have put in place this year with the introduction of the Rocket Open AppDev for Z Solution Bundle. We have switched from sort of old style, one at a time download of tarball and FTP it and then run through ten steps to set environment bevels and get it installed for each source tool or language. And as an example, GIT, which has four dependencies meant four or five downloads. Then you FTPed them over, and then you do the 10 steps four or five times. It’s like _____ way. We’ve switched to conda as the system for downloading, installing, and deploying open source on z/OS. That has made a huge difference in terms of the user experience and the ownership experience.

    So it’s now once you have conda installed on your mainframe, that takes about 30 minutes including the download and the setup, then it’s a single command to install Git and all of its dependency from the command line; and further, conda has this concept of a channel which is their word for a software repository or repository of software you download from. Conda supports something called a file channel as well as internet channels.

    So in addition to this, we have set up two internet channels at Rocket, one public one at anaconda.org that anybody in the world can use to download from and a secure channel server on our network that is authenticated for our customers on support. And then additionally you can set up a file channel which is on your premise which is ideal for air gap systems. So if you have an air gap mainframe, you don’t want it to have a connection to the internet, you can set up a file channel, populate it with the full contents of our bundle and then all of the developers within your organization can download at will from your on premise channels. That’s a big advantage in the area of security. 

    Ashley: Those some really big ones, big changes. 

    Willging: It is a big change. I mean there are a lot of companies that have said that the only delivery mechanism for software to my mainframe is through IBM Shopz. So you know, I have some feelings on that. I think that’s old school thinking as far as I’m concerned, but there’s still a culture amongst many mainframe customers that that’s it. I think that is changing and to make it simple, to guarantee that it’s secure and to provide options is what Peter just went through I think is important to help increase adoption of open source on the mainframe. And so Rocket is really leading in that area to help make that possible. 

    Ashley: It is culture. It is sort of tried and true. You know, if it’s not broken don’t fix it. But on the other hand, when you start to demonstrate new capabilities, new benefits, speed improvements, more security, whatever it might be, access to innovation, suddenly that becomes maybe a compelling reason to start to break down some of those traditions or barriers or kind of think about adding this as a capability. You’re not talking about changing everything, right? We’re talking about adding capability to how you create software in a mainframe and expanded environment, correct?

    Willging: Yep, exactly. 

    Fandel: Sure. 

    Ashley: Good, good. Well, where can folks learn more about this? I don’t know if you have any trials or free downloads or you’ve been in beta on some things that are GA or coming out in GA. What’s the best way for folks that want to engage with you and find out more and kind of give this some –

    Fandel: I think you can Google z/OS Miniconda. You can Google Rocket Open AppDev for Z which is the product release from September and that will lead you to our product pages, our download page, documentation on how to install z/OS Miniconda which is the bootstrap to get you started. There is a couple of published videos. If you look at the Open Mainframe Projects Summit from September and look for, under the video there, “Demonstrating a Secure System for Downloading and Installing Software on z/OS,” you’ll find a video there that shows how it’s used. 

    Willging: The only thing I’d add to that is go check out zowe.org.

    Fandel: Thank you, Tim, yes, absolutely, zowe.org.

    Ashley: Don’t want to look past that, of course. 

    Willging: It completes everything else Peter said. 

    Ashley: Very important. 

    Willging: Important stuff. We haven’t really talked much about Zowe, but yeah. 

    Ashley: We’ll have a chance to do that. Would love to have you back and we can delve into that. I really would like to explore some more about this delivery of software into production and how do we start to evolve and expand helping more organizations consider how they might do that so there will be some great areas to explore further. So look forward to doing that with you. It’s been a lot of fun talking. Any parting thoughts before we wrap things up here?

    Willging: Just real quick, I’d encourage those mainframe z/OS shops, if you don’t have a policy for downloading, consuming open source, I encourage you to get your thought leaders together, you know think about the advantages that open source will provide in your modernization efforts. Check out zowe.org but create a policy to not only to consume but contribute. Get involved in the projects. It’s a way to expand your employees’ interest in the mainframe to make that open source there available. So if you haven’t done it, you really should do that. 

    Ashley: Access to more talent I think as Peter was mentioning earlier. It really is opening up new pathways as opposed to replatforming and a lot of not very attractive options sometimes that you now have because of open source. So folks definitely should consider this, look at it, get into it, get involved. Great. Well, gentlemen, it’s been great talking with you, both Tim Willging and Peter Fandel from Rocket Software. Take care, gentlemen, we will see you next time. 

    Willging: Thank you.

    Fandel: All right, thank you. Take care. Bye-bye.

    Willging: Bye.

  • DRY Comes to COBOL in IBM Z Development

    DRY Comes to COBOL in IBM Z Development

    Don’t Repeat Yourself (DRY) is a fundamental tenet of modern computer programming. Just about every CS student is taught that duplicating code in an application is an accident waiting to happen. The hazard is that you might alter a piece of code in one place, only to leave another identical instance of that code unchanged. Then when you run the code all sorts of strange things happen. In some cases, the changed behavior is in force. In other cases, it’s not. Maintenance becomes a nightmare.

    These days adhering to the principle of DRY is not that difficult. Object-oriented languages such as Java, C# and Objective-C make it easy to encapsulate a set of functions into a class that can be reused throughout an application. Also, technologies such as RPC, XML-RPC and gRPC make it possible to expose distinct functions to the network in a sharable manner. When a single piece of code can be easily shared at runtime, the risk of writing redundant code goes down. Why reinvent the wheel when you can just use one that is pre-existing and well known?

    However, this has not always been the case. In the early days of programming, lines of code executed sequentially. You started at line 1 and ended at line 200. There were no side trips in the middle.

    Language designers were aware of this shortcoming and made it so programs could jump around the lines of code. You could start at line 1 and run to line 20, then jump to line 190 and run to line 220, coming back to line 21 and then jump again to exit out at line 240. It was definitely hopscotching, but it worked.

    Procedural programming arrived soon after and with it came the early forays into segmenting code into a discrete unit of execution, the function. Functions introduced the concept of code sharing within an application. Still, a framework of sharing a single unit of code among an entire system, let alone many systems, on the network took a while to develop. As a result, in the early days of programming code redundancy was rampant.

    The thing to remember is that the proliferation of redundant code was not so much a reflection of professional incompetence. Rather, it was due to the absence of a programming framework by which to avoid code redundancy.

    But, that was then and this is now. Today, DRY is a standard operational mantra. This is good. On the other hand, there’s still a lot of redundant code out there, particularly in shops that have a lot of legacy COBOL. Remember, COBOL just celebrated its 60th birthday. It’s been around for a while.

    Fortunately, the world of redundant code in the COBOL is about to become a whole lot smaller with the introduction of Duplicate Code Detection Technology Preview that’s built into IBM Developer for z/OS.

    Understanding Duplicate Code Detection Technology Preview

    The Duplicate Code Detection Technology Preview (DCD) is a feature supported by IBM Developer for z/OS (IDz) that automatically discovers duplicate code within a given codebase. It’s an optional feature, available as of version 14.2.2, that needs to be added during IDz installation. DCD is an enterprise-level tool that’s intended to be used with very large amounts of COBOL source code, at the level of a million lines of code or more (See Figure 1).

    Duplicate Code Detection Technology Preview for IBM Developer for z/OS
    Figure 1: Duplicate Code Detection Technology Preview for IBM Developer for z/OS exposes duplicate code for elimination or refactoring.

    Once duplicates are identified, developers can use DCD to justify whether the given redundancy is appropriate or if it’s a duplication that needs to be removed. Thus, DCD can be used as a tool to assess code quality and as a tool to refactor the codebase.

    See Duplicate Code Detection Technology Preview in Action

    At IBM’s upcoming webinar, “Duplicate Code Detection — Simpler & Faster Thru’ Out the Lifecycle Webcast,” on May 20, 2020, from 9 a.m. to 10 a.m. (ET) you’ll get an in-depth look at Duplicate Code Detection Technology Preview for IBM Developer for z/OS. Architects Herve Le Bars and Jean-Yves Rigolet will be on hand to go over the details for using DCD to eliminate duplicate code and improve code quality.

    The webinar is free and it’s filled with important information that’s sure to enhance the productivity of developers using IBM Developer for z/OS. You can register for the DCD webinar here.

    How Duplicate Code Detection Technology Works

    Duplicate Code Detection Technology is an optional feature that can be fully integrated into IBM Developer for z/OS. Developers can use DCD as a standalone application to search for duplicates in his or her workspace. Also, developers have the added benefit of sharing duplicate code detection results among a team. In order to have a collaborative experience with Duplicate Code Detection, three additional components need to be installed on the server-side. These components are:

    •     IBM Websphere Liberty Server
    •     Duplicate Code Detection Feeding Agent
    •     Source Code Management System

    Let’s take a look at how it all fits together.

    As mentioned above, developers can use DCD with IBM Developer for z/OS to examine the individual developer’s workspace for code duplication. In this case, DCD is essentially a stand-alone tool (See Figure 2, callout 1).

    Duplicate Code Detection
    Figure 2: Duplicate Code Detection works standalone and as a collaborative tool.

    While it is beneficial to have an individual developer detecting duplicate code in his/her workspace, it’s limited in scope. There is only so much work a single developer can do. Where things get really powerful is when the result of searches for code duplication can be shared among the team. This is where using DCD in a client-server architecture comes into play.

    Central to the DCD client-server architecture is the DCD Server which is an IBM Websphere Liberty Server and the DCD Web Application.

    The DCD Server is used to share the results of duplicate code detection across members of the development team. Developers interact with the DCD Server using the DCD component running within IBM Developer for z/OS (See Figure 2, callout 1, above).

    On the server-side, there is an independent client, the Duplicate Code Detection Feeding Agent that acts as a bridge between the source code stored under a source control management system and the DCD Server.

    The feeding agent asks the SCM for the changed COBOL files in the source code management system (See Figure 2, callout 2). Then the DCD Feeding Agent sends the changes to the DCD server (See Figure 2, callout 3).

    The DCD server keeps track of duplicate code (See Figure 2, callout 4). As mentioned above, team members access the DCD server using IBM Developer of z/OS to visualize the duplicate code information. The DCD feeding agent works incrementally: Only changed COBOL files are transferred for examination, thus reducing operational overhead.

    You can read the details for installing and configuring Duplicate Code Detection by downloading the DCD Installation Guide.

    The Benefits of Using Duplicate Code Detection Technology

    There are many benefits to using Duplicate Code Detection Technology. Automated duplication detection simplifies refactoring. Duplicate Code Detection Technology identifies redundancies that occur throughout millions of lines of code automatically while leaving it up to the developer to judge if the code duplication is justified or not. If duplicates do need to be removed, DCD allows developers to make the changes at once, thus saving time while improving productivity. Remember, Duplicate Code Detections works at lightning-fast speeds. It takes on average 100 milliseconds to search 100,000 lines of code.

    Also, when distributed collaboration is enabled using the DCD Server, searches can be shared with team members and stored for later use, thus improving collaboration efforts among teams and team members.

    Duplicate Code Detection enhances search efficiency by examining code stored directly in source control management repositories. DCD improves code readability while reducing complexity. In addition, it supports versioning using standard source control management frameworks, such as GitHub.

    Putting It All Together

    The principle of DRY is commonplace these days. While it’s been a principle that’s easier to implement in younger companies, those businesses with codebases that go back decades have found adopting DRY to be difficult. Refactoring can be risky. Many companies think that unless there’s a compelling reason to refactor the old code, most times it’s better to leave well enough alone, particularly if that code is written in COBOL.

    But as the dramatic need for COBOL programming talent at the New Jersey Department of Labor recently revealed, COBOL matters. And, when that COBOL code is refactored, which is sure to happen, applying DRY in the refactoring effort will be a driving principle. Hence, the opportunity exists for DCD to play a key role. It’s a compelling technology. Given the power that DCD brings to the COBOL programming experience, implementing the DRY principle against both current and legacy code requires no more labor than the work that goes with spell checking a large document.

    Duplicate code has been the bane of developers since the first Hello World was written over half a century ago. Over time the situation has improved, but for many companies it’s still a problem, particularly companies with a large legacy of COBOL programs. Companies that make Duplicate Code Detection Technology part of their COBOL programming toolbox will not only have the benefit of creating code that is more elegant, more readable and of higher quality, they will be well on their way to placing the DRY principle at the forefront of their software development activities.

  • IBM Advances DevOps on the Mainframe

    IBM Advances DevOps on the Mainframe

    IBM has expanded its efforts to bring DevOps best practices to the mainframe by adding automated unit testing capabilities for CICS COBOL programs using Db2 to IBM Developer for z/OS (IDz) V14.2.1. The company is also making an instance of z/OS available within a Docker container that can be deployed on an x86 platform.

    Sanjay Chandru, director for IBM Z DevOps, said both capabilities will play a critical role in enabling IT organizations that have invested in mainframe to be much more agile. The Docker x86 capability will enable developers to build and test applications without requiring access to a mainframe, while IBM’s automated unit testing tools provide a much lighter-weight alternative to previous generations of tools, he said.

    In addition to automating assertions and pass/fail checks, the automated unit testing capability for IDz makes it possible to invoke the tests from within either the tool itself or as part of a continuous integration/continuous delivery (CI/CD) pipeline, Chandru said. DevOps teams also can now store tests in a modern source code management application alongside the code being developed, he added.

    The IBM unit testing tool can now intercept EXEC CICS and EXEC SQL application calls under CICS to allow data capture during a live run. This recorded data can then be used to create additional tests, including negative tests, in a virtual environment without having CICS because tests are now run as a batch job, Chandru said.

    Finally, IBM is also making it possible to export test results in PDF or XML in addition to JUnit and SonarQube formats.

    Chandru said interest in applying best DevOps practices in mainframe environments has increased dramatically as organizations embrace digital business transformation initiatives. Almost invariably, projects access applications that run on mainframe environments but still process most of the data within enterprise IT environments, he noted. Many organizations are now developing microservices-based applications that rely on mainframes at their back end, he added.

    However, given the rate at which those applications are being developed, legacy approaches to building and deploying mainframe applications are not able to keep pace with the rate of innovation now expected, said Chandru. As a result, IBM is encouraging organizations that have mainframes to shift responsibility for building and deploying applications much further to the left, he said.

    Long term, IBM wants to make developing applications for the mainframe “unremarkable” in the sense that tools for building and deploying applications for any platform should work equally well on mainframes, Chandru said, noting that approach will significantly expand the pool of developers that can build applications for the mainframe.

    It may be a while before DevOps best practices are employed pervasively across mainframe environments, many of which are steeped in legacy waterfall approaches to application development. However, there are pockets of IT teams within mainframe environments that are starting to appreciate the need to be able to respond to changing requirements more rapidly. The only issue that remains now is to determine just how deeply best DevOps practices on the mainframe will be embraced.

    — Mike Vizard

  • Automated Multiplatform Deployment for DevOps

    Automated Multiplatform Deployment for DevOps

    In a simpler world, every CI/CD pipeline would need to support only one deployment platform.

    In the real world, multiplatform deployment (which means deploying an application to run on multiple OS platforms) is a must-have for many organizations. We live in an age of diverse operating systems and deploying for only one platform is often not an option.

    With that challenge in mind, let’s take a look at best practices for achieving multiplatform deployment in DevOps.

    Dealing with Multiplatform

    Maybe you’re designing a container-based multiplatform app from scratch. Perhaps you’re thinking of converting a traditional, monolithic, client-server application to microservices with continuous delivery. Or, it may just be time to expand your existing DevOps delivery pipeline to include multiple platforms. The truth is that sooner or later, most DevOps teams will need to understand and deal with multiplatform deployment and how it impacts continuous delivery and continuous integration.

    What are the basic problems DevOps teams face in orchestrating automated deployment for multiple platforms? Let’s look at the key issues involved in multiplatform deployment, and the most effective ways to deal with those issues within the context of an automated DevOps continuous delivery chain.

    But first, we’ll consider one of the most basic distinctions in multiplatform architecture.

    Multiplatform, Single-Tier

    In the single-tier model, the same stand-alone application is deployed to multiple platforms. This is, of course, the standard model for releasing traditional desktop applications. The update process for many of those applications, however, has shifted toward frequent, automatic push updates to the point where it now constitutes a form of continuous delivery. This is typically the case for web browsers, for desktop office suites and for more specialized applications. It is also the rule for stand-alone mobile apps.

    Multiplatform, Multi-Tier

    In multi-tier and multiplatform deployments, different platforms have different roles, and the elements of the program deployed to a platform depend on its role. Typically, this involves some sort of client-server architecture, with the client part of the application installed on mobile and/or desktop devices, and the server functionality deployed in a cloud or hybrid cloud environment, or an on-premises server. At the enterprise level, on-premises hardware is likely to consist of one or more mainframes.

    We’ll focus mostly on multi-tier applications; much of what’s covered here should, however, also be relevant to single-tier multiplatform deployments.

    Designing for Multiplatform Deployments: Overall Architecture

    Fundamental decisions about application architecture will inevitably have a major impact on your deployment strategy. Key members of your DevOps team should ideally be active participants in decisions regarding overall architecture; at the very least, your team needs to be kept up to date on the design process.

    This is particularly true when the application has a hybrid backend, with key tasks split between cloud services and on-premises hardware, since the allocation of tasks is likely to shift as the design team develops a better understanding of both the resources required for those tasks and the load-handling ability of each platform.

    Example: Cloud Transactions, Mainframe Database

    Suppose, for example, that you have a very large and complex database that includes both customer and transaction records. It must be maintained on a mainframe because it includes legacy elements, or for security reasons, because of company policy, or (as is often the case) for all three reasons. Your application is likely to involve a high volume of transactions and other customer traffic, most of which will be stored in the database. In order to shift traffic away from the mainframe, customer interactions will be processed in the cloud, with transaction data initially stored in a cloud database, then transferred to the mainframe database.

    • Will the cloud database represent an actual field-for-field subset of the mainframe database, or will data need to be cleaned up and parsed before it’s transferred to the mainframe?
    • Will you be porting database code from the mainframe to the cloud, or creating a cloud-native database (i.e., COBOL vs. SQL)?
    • Will all user access be through the cloud interface, or will the app switch between the cloud and direct access to the mainframe, depending on the load?

    Questions like these are likely to have a major effect, not just on microservice and code-level design, but also on deployment strategies, since they will determine such things as how closely database microservices must be coupled on the two platforms.

    Designing for Multiplatform Deployments: Platform-Specific Issues

    In order to design a multiplatform application at the end-user and backend microservice levels, and deploy it using automated tools, it is crucial to have a clear and detailed understanding of the resources available on each platform, and of the dependencies they require.

    For the frontend, this may mean maintaining separate versions of your app for Android, iOS, Windows, OSX and Linux. For the cloud-based parts of your back end, you may be able to work in a relatively standardized container environment. Even here, however, you will need to be familiar with the resources and requirements of the specific cloud provider.

    On mainframes, you will need to have a good working knowledge of the mainframe environment, including the operating system and the available resources. This is a necessity for native mainframe operating systems such as z/OS, and it is still largely true if you intend to use a virtualized OS such as Linux on Z, since it is likely to have significant interaction with the underlying system resources.

    Designing for Multiplatform Deployments: Automating the Pipeline

    Keeping track of platform-related issues and managing their impact on your continuous delivery pipeline may seem like a formidable task, but it doesn’t have to be that difficult.

    The key is to develop an adequate understanding of the platforms involved, to incorporate that understanding into your automated tools and all of the target platforms into your automated delivery chain. This means (for example) automated testing across platforms, dependency checking for each platform, coordinated deployment and integrated monitoring.

    A variety of tools, both open source and proprietary, are available for all of these purposes and they can often be integrated into an automated continuous delivery system.

    Integrated Tools for Multiplatform Deployment

    There are, however, considerable advantages to using a highly integrated suite for fully orchestrated deployment. For example, if you are working with IBM Z, UrbanCode provides you with an integrated suite of DevOps tools that is fully integrated into the z/OS ecosystem. It is an agent-based system that includes tools for design of automation processes, multiplatform deployment, dependency checking, inventory and integrated monitoring; and it is specifically designed to manage multi-tier deployments.

    The advantage of working with a highly integrated deployment suite such as UrbanCode is that you do not need to spend time learning what to automate, learning how to automate it or putting together the basic automation infrastructure. You can concentrate on managing the specific automation components and settings your continuous delivery system needs. When you are dealing with a large, complex and business-critical platform such as a mainframe, an automated deployment suite that is highly integrated with that platform, can be an extraordinarily valuable (and time-saving) resource.

    Automated multiplatform deployment for DevOps may be challenging, but it’s eminently possible. The tools are there, and you can make it work.

    — Michael Churchman

  • The Competitive Advantages of Modern SCMs

    The Competitive Advantages of Modern SCMs

    Source code management (SCM) is not a new concept. It has been in existence since around 1980, when Revision Control System (RCS), one of the first major SCMs, was released.

    But that doesn’t mean SCM today is the same as it was decades ago. Modern SCM tools do much more than their predecessors. They handle not just application code, but all the configuration scripts and templates used to build and support the infrastructure that applications rely on.

    Here is an explanation of what a modern SCM can do for you, and why it’s important from a business perspective to have a modern SCM.

    What Do SCM Tools Do?

    SCM tools, also known as version control systems (VCSs), at their most basic level, provide a history of all changes to one or more files and directories within a repository. These tools are most effective on text-based files such as source code and configuration files, as they can show line-by-line differences. While some tools can do specific binary file types (such as Microsoft Word documents), typically, binary files are stored intact, and each change results in a whole new copy being saved.

    An example of what metadata is tracked in the history (CLI-based example):

    $ p4 changes

    Change 2 on 2019/04/19 by dev@desktop ‘deletion of library.dll’

    Change 1 on 2019/04/18 by dev@jenkins ‘Initial commit’

    …

    You can display what has actually changed in each file (GUI-based example):

    Distributed vs. Centralized SCM

    There are actually three models of SCM tools: local-only, centralized and distributed.

    There is currently no modern SCM tool that runs local-only. Modern SCMs have evolved beyond a local-only architecture.

    Centralized SCM tools work by having every change committed directly back to the source server that is the authority for whatever is being worked on. There is code hosted on the local workstation, but any and all changes are tracked on the server. This model was dominant in the late 1980s and is still extremely popular in many large enterprises. The benefit of having everything centralized is all changes are tracked, and it is easy to stay in sync with the authoritative repository that leads to very few conflicting merges. The downside is a constant connection to the network is required to get any work done.

    Distributed SCM tools came out of obscurity in the early 2000s with their biggest proponent: Linux kernel development. Linux kernel development had evolved into a globally dispersed team, and not all members had the bandwidth or always-on connectivity needed to continue to use their centralized SCM toolset. The biggest benefit of the distributed model is each workstation has a complete copy of the entire repository and can locally branch, tag, revert and commit changes. At certain points (often daily, sometimes weekly), each developer syncs their local repository with the remote repository (which can loosely be called the authoritative version). The biggest downside is a much higher likelihood of conflicting changes being applied to files in the repository if there isn’t a lot more coordination around the process. It isn’t enforced with locks like it is in a centralized model.

    Why Use SCM Tools?

    Reproducibility and traceability. Period. It really is that simple.

    With SCM tools embedded in your development and support lifecycles, you can produce the code used for any version at any time, which will let you reproduce the binaries that were running in production. In addition, you can trace back to who actually changed the line of code that either fixed the defect or broke the world.

    Let’s go through a few scenarios where this can make all the difference.

    1. Fixing an ABEND from a Job that Only Runs Quarterly

    It’s 3 a.m., and you receive a phone call from operators saying your job has ABENDed, and their normal remediation steps didn’t fix it.

    Without SCM in place, you can only work with the code you have. You are in the middle of refactoring it, so it is in no shape to go anywhere near production–leading to meetings full of apologies and late nights spent working.

    With SCM, you check the tags in the repository and pull the latest production build, fix it, test it, push it to production and have the job back up and running before others make it into the office. Then, you can create a new tag, and there is a record of what was done.

    2. Discovery in a Lawsuit for an Event that’s Six Years Old

    This is pretty straightforward. We live in a world where companies love to sue each other, and your legal team will appreciate your ability to reproduce things as they were so you can prove what does or doesn’t work as expected, or does or doesn’t include whatever patented code the other side claims. No one likes to lose a default judgement.

    3. Client Finds a Bug in the Older Release They Still Run

    This applies to managed offerings or when the client installs the software on their own; there is always that one client who for some reason can’t upgrade.

    In this case, inside your SCM tool, as a best practice you would create a branch every time you do a release of your product. On that release branch, you can easily make code changes and rebuild and distribute the new, updated binaries of a version that was originally released two presidents ago, without having any impact on other customers or your own production deployments.

    Timeline of Popular SCM Tools

    There are dozens of version control tools and discussing the evolution of each one would fall far beyond the scope of this publication. However, there are a few key SCM tools that have led the way in establishing standards and norms for the industry. Their history is outlined here.

    1. Unix

    Concurrent Version System (CVS) was the first widely used SCM tool in the Unix ecosystem. It was a pioneer in the centralized approach when it was released in 1990. CVS is heavily based on RCS (to the point that most RCS repositories were seamlessly converted).

    Microsoft had a tool called Visual Source Safe (VSS) that it supported and distributed from the mid-1990s through the early 2000s. VSS was good for the typical mid-sized source code repository. Microsoft did not use VSS internally, as their internal needs were too complicated and their code repositories were too large for the tool.

    2. Cross-Platform SCMs: Perforce, ClearCase and SVN

    Perforce was the dominant source management tool used within Microsoft for decades. Perforce supported the level of complexity Microsoft and other large enterprises had around tagging and branching. It was also cross-platform like other popular tools such as PVCS, which helped it support development across all facets of a large enterprise’s infrastructure, from mainframes to Unix to Linux to Windows.

    Rational ClearCase (later bought by IBM) was heavily used by larger enterprises across all platforms, especially when mission-critical systems that leveraged big iron hardware and service-oriented architecture were involved. While ClearCase was a centralized system, it had several features that were unique and valuable to distributed teams, including dynamic views, which could be remotely mounted, and true code-level integration with Rational ClearQuest to track exactly what was changed in each defect and request. These concepts were revolutionary, but required large and reliable network interconnections, which is why distributed systems have become more commonplace today.

    While enterprises were adopting PVCS, Perforce or ClearCase, many open source, web-scale and smaller organizations were adopting Subversion (SVN), released in 2000. It built on CVS’s success and specifically addressed a couple of major annoyances with CVS’s architecture, which included repository-wide versions (which allowed a more consistent approach to versioning applications), as well as atomic commits (meaning the entire change is applied at once—if any of it fails, then the entire change is rolled back).

    Rational Team Concert, which emerged in 2008, represented another important point in the evolution of SCMs. It was cloud compatible and offered features (such as build management) that extended beyond just version control.

    The Git Revolution

    The world of SCM changed significantly with the introduction of Git, which was released in 2005.

    Initially developed by the Linux kernel development team, Git built on the lessons learned from a previous product the team used, called BitKeeper. Git is a truly distributed SCM tool and is now the dominant SCM tool for all new development. Git is multi-platform and has the largest mindshare across organizations of all sizes.

    Git has a much larger ecosystem around it than previous SCM tools enjoyed, and multiple vendors offer solutions that are built on it. Git is the default tool for most modern continuous integration tools, such as Jenkins.

    Using Modern SCMs with z/OS

    On the mainframe, SCMs developed in parallel to other platforms, but remained entirely separate in their implementation. Products such as Endevor, ChangeMan and ISPW were born as Library Managers, but were later used for version control. Still, the core technology that powers them is over 20 years old. They have remained substantially unchanged throughout their lives.

    Recently, however, with the rise in popularity of of hybrid applications and the adoption of lean/agile development processes, the legacy SCMs have come under increasing pressure to modernize. The vendors who produce these products have belatedly tried to bolt on modern capabilities; and where this has been proven impossible or impractical, they have elected to integrate with Git. However, since Git is now fully supported on the z/OS platform, organizations requiring the capabilities of a modern SCM are able to use Git without the hindrance or cost of a legacy SCM.

    You might think developers who work on legacy platforms such as mainframes, have to abandon their entire environments in favor of modern ones in order to take advantage of modern SCMs. Fortunately, that is not the case. Tools such as Dependency Based Build (DBB) bridge the divide between mainframe apps and modern SCMs. DBB lets mainframe developers use Git to manage source code for z/OS COBOL applications. It also supports Groovy for managing builds.

    Git, and the build tools that integrate with it, have become the go-to SCM solution for virtually all developers today, on most platforms. With the rapid uptake of Git already on Z, and tools like DBB available, it is clear Git is also going to become the dominant SCM for the z/OS development.

    As teams modernize their practices to handle the explosion in the sheer number of applications being built and the infrastructure automation scripts that support them, moving to an agile development methodology or trying to take advantage of DevOps practices such as continuous integration (CI) is impossible without a modern SCM tool to push all the changes through.

    Modern SCM tools are the foundational building block every technology team needs to successfully support all aspects of an application’s lifecycle.

    — Vince Power

  • Shift-Left Testing, Continuous Integration and the Mainframe

    Shift-Left Testing, Continuous Integration and the Mainframe

    “Mainframe” is one of the oldest terms in tech. “Shift-left” is much newer.

    You may not think, then, that mainframes and shift-left testing have much in common. But you’d be wrong. Shifting testing to the left can deliver tremendous benefits, even in the context of mainframe applications.

    Let us explain.

    What Is Shift-Left Testing?

    Shift-left testing refers to the practice of performing more tests earlier in the software development lifecycle.

    Traditionally, most testing occurred just before software was deployed into production environments. Testing code at this stage is useful for ensuring it will behave as expected in production, but it comes with drawbacks.

    The biggest drawback of traditional testing is problems are difficult to fix if they are not discovered until just before software is ready to be deployed. At that point, addressing a problem within the code requires determining where specifically the problem exists within the code, removing that code from the application and replacing it with updated code—all without breaking other parts of the application that depend on the original code.

    Shift-left testing helps to address this problem by encouraging software delivery teams to perform tests earlier—typically, starting right after individual units of code are written. Being able to test earlier and more often is especially important in software delivery pipelines based on continuous integration/continuous delivery (CI/CD), where the goal is to roll out application changes on a nearly continuous basis.

    Since bugs that aren’t detected until just before release can take a long time to fix, a lack of shift-left testing puts organizations at risk of not being able to achieve the main goal of CI/CD due to constant delays caused by software quality problems. In addition, shift-left testing reduces the amount of overall end-to-end testing you have to perform.

    You Still Test on the Right

    It’s important to note tests performed earlier in the pipeline don’t replace the testing done just before deployment. They complement them and reduce the chance of having problems go undetected until right before deployment. In this sense, the term shift-left can be a bit misleading; it’s not really about shifting all testing to the left of the delivery cycle, as much as it is starting tests earlier, while continuing to test on the right of the pipeline as well.

    Shift-Left Testing and Continuous Integration on the Mainframe

    Shifting testing to the left makes it easier to fix code problems within virtually any type of application delivery pipeline based on CI/CD. But it can deliver especially critical benefits for software delivery teams striving to bring mainframe applications up to speed with CI/CD.

    There are a few primary reasons why. One is mainframe applications are usually written using older programming languages that were not designed to help developers avoid mistakes. This isn’t to say mainframe languages are especially prone to errors; they’re not. But compared to a language such as Python, which is designed to enforce good coding habits, a language like COBOL doesn’t exactly require programmers to be highly disciplined when they’re typing out their code. Thus, it’s especially important to be able to catch bugs earlier within code written in a mainframe language.

    Another factor is mainframe applications are often part of legacy codebases. When you’re dealing with code and dependencies that are decades old in some cases, you’re at a greater risk of ending up with software quality problems, despite your best efforts. Here again, detecting those problems earlier rather than later means they can be fixed without interrupting the entire CI/CD process.

    Finally—and most important—is the fact that in some cases, there is a large disconnect in terms of skill set and familiarity with mainframe code between software quality engineers and mainframe programmers.

    Your typical QA engineer today didn’t grow up with z/OS and may have limited experience troubleshooting software problems. Given the QA team is typically responsible for running pre-deployment tests, this can pose a problem in the event that QA detects issues with a mainframe application that it has no idea how to troubleshoot, let alone fix. By shifting testing to the left, it’s easier to give developers faster feedback so that they can fix bugs more quickly.

    How to Shift Mainframe Application Testing to the Left

    If you thought mainframes had nothing to gain from the shift-left testing movement, you might also think there aren’t many tools out there to help you do shift-left testing for mainframes.

    Fortunately, that’s not true at all. For unit testing, IBM offers Z Unit, a unit-testing tool for z/OS programs. Z Unit is included in Z Open Unit Test and IBM Developer for z Systems. Using these tools, Z developers can automatically generate unit tests for batch and CICS programs as part of their daily work. These tests can be stored in any standard SCM and can be executed independent of their environment.

    You can even test mainframe apps on non-mainframe hardware using Z Development and Test Environment. The platform creates virtual Z environments on x86 systems so developers can write, build and test their mainframe applications on any standard commodity server or development box.

    Conclusion

    Whether your mainframe applications are decades old or have been written from scratch in just the past few years, there’s nothing stopping you from taking advantage of shift-left testing to help validate them. Doing so will make it easier to achieve CI/CD effectively for your mainframe application, which keeps your software delivery team and your end-users alike happier by reducing bugs and delays.

    Check out the Z Open Unit Test demo.

    — Chris Tozzi

  • Achieving Open and Integrated Development with IBM Z

    Achieving Open and Integrated Development with IBM Z

    “DevOps” and “mainframe” are not words you often hear in the same sentence. Yet, the reality is that even in our current age of DevOps, mainframes remain the mainstays of many companies’ IT infrastructure.

    That’s why it’s critical for organizations to find ways to bring mainframe software delivery up to speed with modern DevOps practices, which emphasize collaboration, agility and continuous deployment of software to meet quality and time-to-market pressures. It’s also essential to be able to de-silo software delivery teams with a unified pipeline that includes common, modern source code management (SCM) and other tooling.

    This is one area where the IBM Z Open Development environment can deliver real value. Built with the goal of supporting modern source code managers such as Git, IBM Z Open Development helps make a common DevOps pipeline, including mainframe teams, more practical through use of modern, open SCM, plus other essential features for developers.

    Keep reading for details on how Z Open Development works and what it can do to make mainframes DevOps-friendly.

    IBM Z Open Development: Making Developers’ Lives Easier

    There is a looming shortage of mainframe developers as the current experts retire; according to BMC’s 2018 mainframe survey, staffing and skills shortage is the second top concern for the mainframe ecosystem. This is not an ideal situation for organizations that rely heavily on mainframes. To solve it, organizations must allow all developers to work on mainframe software, instead of relying on mainframe specialists.

    With Z Open Development, developers are armed with the capabilities they need to integrate mainframe work with a common DevOps pipeline that employs a modern, shared SCM. They also have the ability to perform program analysis, edit, build and debug in a way that is similar to other development platforms.

    Git is the de facto SCM for the open source community, and enterprises are also embracing Git as the standard SCM for distributed software delivery. Z Open Development makes key Git features such as full Isolation and true parallel development, a reality for mainframe development teams.

    Traditional mainframe library managers don’t offer these features; hence, they don’t overcome the isolation that separates mainframe development from development for other platforms. Z Open Development tackles this problem by offering IBM Dependency Based Build and provides enterprises a standardized implementation of Git.

    Essentially, Z Open Development is purpose-built IDE for developing and maintaining z/OS application components with a modern SCM that supports parallel development. It provides integrated development and build automation, which can be joined with a common DevOps pipeline. This provides a path to migrate traditional mainframe library managers to modern source code management systems such as Git and Rational Team Concert.

    Key Features

    Z Open Development is a neat and lean offering that can help development teams transform their software delivery around a common, automated delivery pipeline. Z developers can join a platform-neutral, continuous integration and deployment pipeline that is inclusive of z/OS. However, Z Open Development offers other attractive features that developers require:

    1. Dependency-Based Build

    IBM’s Dependency Based Build (DBB) allows clients to set up the build for COBOL, PL/I and other traditional z/OS languages just as they would other distributed languages through the use of modern scripting languages. By following the same model as distributed languages, and using standard scripting languages such as Groovy, the z/OS build can be easily added to the same CI/CD pipeline and managed by the same skills building the pipeline today. This ability to use the same CI/CD pipeline coordinator (such as Jenkins) removes the separation and allows for the creation of one coordinated pipeline. This includes being able to standardize on the approval flows, using the same quality gates and supporting the integration of the multiple parts of the application together.

    DBB extends the Groovy language with an additional set of java APIs to allow access to run MVS, TSO and ISPF commands, as well as a facility to run existing JCL. DBB also provides a set of open source samples including a configuration-based build that can be used within your own organization, with minimal modifications.

    With its GroovyZ capability, DBB also supports the ability to do automation in the pipeline for any additional configuration required. Since it’s Groovy, existing automation created for other platforms can easily be reused for z/OS.

    2. Modern Editors

    Developers can use modern editors for COBOL, JCL and PL/I to develop their applications. These editors are familiar and provide syntax highlighting and source code assistance to make coding a breeze.

    3. Visual Program Analysis

    Developers can check out the graphical views of the logical flow of any program they are working on for better program understanding. Developers can also access the graphical view of data flow within their program to identify different data elements and understand how they are populated and modified.

    4. IBM z/OS Debugger

    Z Open Development comes with the powerful Eclipse-based, source-level IBM z/OS debugger, which can be used to debug 24 and 31-bit z/OS applications written in COBOL and PL/I. Developers can modify variables during debugging while also being able to insert breakpoints during or prior to debugging. The visual debug capability provides developers with a graphical view of the execution flow through their program.

    5. Simplified Integration

    DBB integration with the editor enables developers to compile the programs using the same scripts defined for the pipeline build, which includes copying files with any dependencies to a specified host, running a build process and returning errors.

    If the shared, modern SCM for the DevOps pipeline is Rational Team Concert (RTC), Z Open Development also offers RTC integration.

    6. The Foundation for Z Open Unit Test

    In addition to all of the above, Z Open Development lays the foundation for Z Open Unit Test, a unit testing tool for z/OS applications built on the Z Unit capability. Thus, Z Open Development allows developers to streamline and automate not just their SCM process, but also unit testing. Note that the Z Unit capability is also offered in IBM Developer for z Systems.

    Empowering the Endangered

    DevOps is based on the idea of eliminating silos to have a more collaborative approach to application development for more efficient and predictable output.

    Mainframes have long been isolated, which places them in opposition to the fundamentals of DevOps. Z Open Development arms developers with the capabilities they need to build and maintain mission-critical software while still leveraging a shared DevOps pipeline that includes Git and Jenkins. It offers an easy first step to DevOps adoption and equips DevOps teams with the power to develop mainframe applications with familiar, shared skills and tools.

    — Twain Taylor

  • IBM Extends z/OS Toward DevOps Again

    IBM Extends z/OS Toward DevOps Again

    A few months ago, I wrote about the release of Zowe, the first Open Source project based on z/OS. Zowe is a framework for including z/OS in your applications with less pain than we have traditionally suffered. IBM supported this project as part of its view that enterprises need to have interoperability between platforms.

    This belief also drove IBM’s recent announcement of new pricing models, along with enhanced cloud and container support that will help users tie mainframe access directly into the DevOps toolchain.

    First, let’s cover the pricing. IBM has brought “Pay as you grow” type pricing to the mainframe. While owning a mainframe means you are already expending funds, the new model is designed to simplify licensing and adjust what you are paying based upon actual consumption. It’s not a revolutionary idea, but it is wholly new to the mainframe scene and places mainframe pricing in the same pre-determinable model as cloud. IBM signed on some of z/OS’s biggest developers to offer similar pricing with Broadcom, BMC and Compuware either joining with IBM or offering similar programs.

    And Containers!

    But that’s not the exciting part for those of us in DevOps. The exciting part is the announcement of IBM z/OS Container Extensions. The ability to drop standard containers onto a z/OS partition and use them as an interface to traditional mainframe data/subsystems is huge from a DevOps perspective. This puts both the processing power of the mainframe and the stable data/subsystems into the DevOps cycle by allowing containers to be treated like any other container. Of course, I haven’t (and due to current work requirements probably won’t) played with it, so I’m likely glossing over some issues that users will run into, the potential is staggering. To finally have mainframe access that fits into the DevOps toolchain like any other system would is huge, and shows that IBM is listening to the market. I’ll be following along to see how it rolls out; I’ve got a fair number of associates working in mainframe shops who will keep me posted, but if you roll out Container Extensions, please let me know how it went.

    Cloud Interop?

    I’m less excited about IBM z/OS Cloud Broker. This announcement talks about the ability to spin up z/OS environments in IBM Cloud Private. It seems to me that this is counter to most users’ needs, but I can see that some larger z/OS environments might well have asked for it—rather than pull in another mainframe just for seasonal bumps, the ability to provision in the cloud is appealing. However, the number of organizations that fall into this category is small, though important from an “IBM customer” perspective, so it makes sense that the company went this route, but it’s less about new technology and more about giving important customers a tool to avoid large “forklift” upgrades, IMO.

    And Containers!

    I’m still thrilled to see Container Extensions. I’m looking forward to following where that goes. IBM has been pretty open about the fact that this is a road it is on, not a destination, so no doubt Container Extensions is just a stop along the way. But if it makes it easier for today’s crop of developers and DevOps engineers to access the mainframe sitting in their DC, I’m all for it, and can’t wait for the next stop on this road.

    — Don Macvittie