Command Line Heroes - The Infrastructure Effect: COBOL and Go

Episode Date: August 20, 2019

Languages used for IT infrastructure don’t have expiration dates. COBOL’s been around for 60 years—and isn’t going anywhere anytime soon. We maintain billions of lines of classic code for mainframes. But we’re also building new infrastructures for the cloud in languages like Go. COBOL was a giant leap for computers to make industries more efficient. Chris Short describes how learning COBOL was seen as a safe long-term bet. Sixty years later, there are billions of lines of COBOL code that can’t easily be replaced—and few specialists who know the language. Ritika Trikha explains that something must change: Either more people must learn COBOL, or the industries that rely on it have to update their codebase. Both choices are difficult. But the future isn’t being written in COBOL. Today’s IT infrastructure is built in the cloud—and a lot of it is written in Go. Carmen Hernández Andoh shares how Go’s designers wanted a language more suited for the cloud. And Kelsey Hightower points out that languages are typically hyper-focused for one task. But they’re increasingly open and flexible. You can learn more about COBOL or Go, or any of the languages we’re covering this season, by heading over to redhat.com/CommandLineHeroes. We're passing along a correction that Carmen Hernández Andoh shared on Twitter: she misspoke about Rob Pike inventing ASCII. Bob Bremer is considered the main creator of ASCII. Follow along with the episode transcript

When the New York City subway first started running in 1904, it was a marvel of the modern age. But what happens when today's commuter depends on infrastructure that was designed more than a century ago? Trains are packed and often late. Two billion subway rides take place each year in New York, and nobody's marveling anymore. We're tied to yesterday's crumbling infrastructure, and we have to find smart new ways to make it work. It used to be that infrastructure projects were these big concrete things we could see. That subway, for example. And because of that physical presence, it was also

pretty obvious when they broke down. Highways crack. Telephone poles fall over. We know when those things need fixing. Big efforts are necessary to get our lives in sync with aging infrastructure. But things aren't always so obvious. Today, we also have IT infrastructure, server farms humming in isolated fields, fiber optic cables spanning oceans, and software infrastructure too, like legacy operating systems or shell scripts that nobody dares to replace. When all that IT infrastructure gets old and creaky, we can't see it for ourselves. And yet the infrastructure that makes today's development work possible is aging, just like an old subway track, and that can mess with our modern lives. Massive new challenges emerge as today's command line heroes

work to make sure we're not being boxed in by the past. This is episode five of our season-long journey into the world of programming languages. We're looking at two languages that have intimate ties to the infrastructure they were first designed for. COBOL is a language native to mainframe computing, and GO is native to the cloud. They're both deeply influenced by their origins. Understanding that might save tomorrow's developers from ending up like a New Yorker crammed into Penn Station. I'm Saranya Tbarek, and this is Season 3 of Command Line Heroes, an original podcast from Red Hat. So many things ahead that we have to do. Well, we need tremendous amounts of information,

car-loaded, easy to access. We're only at the beginning. Admiral Grace Hopper pioneered high-level programming languages in the 1940s and 50s, and she was able to make that great leap forward because of the infrastructure of her time, mainframe computers. Hi, my name is Chris Short. Chris is a principal product marketing manager at Red Hat.

And he's a bit of a history buff, too. Admiral Hopper in the 40s made Flomatic. And she's widely considered the grandmother of COBOL, which was revolutionary at the time. So being able to sit there and say, hey, just put it on the mainframe or hey, just store it on the mainframe. It was a major game changer. Suddenly, you've got this machine-independent language, COBOL,

that's native to the mainframe environment. Possibilities started opening up. COBOL with mainframes really gave every organization the capability to say, instead of having a room full of people with pencils and paper and calculators and slide rules, they could just have half a room with a mainframe in it. And then they could have a few people write some applications in COBOL to do all the math and logic and ledgering that their entire finance team could do. So the team of people that you needed to do your finances became a lot less

just because a lot more of the input could be digital as opposed to all hand jam and manually. If you were one of those new COBOL programmers, it would have felt like you had a job for life because the infrastructure that your work was based on, all those mainframes, they weren't going anywhere. Moore's Law wasn't around back then, so you could go an entire decade working on the same mainframe, potentially.

You didn't have to worry about the next operating system or the next type of container orchestrator or the next thing that comes along in AI or whatever, you could probably spend your whole career working on COBOL. And you knew you were going to be pretty safe. But Moore's Law did arrive eventually. New infrastructures showed up too. And these days, programmers are less likely to learn a half-century old language. But here's the thing. Those old mainframes aren't actually gone. And that means our need for COBOL developers hasn't vanished either. It's getting a lot harder to find COBOL

developers. What ends up happening is these mainframes have been here for 50 years, potentially. And these COBOL developers that still can write good COBOL will get paid an exorbitant amount of monies to help with projects and reorganization of data within mainframes. And that skill set is definitely dying off and becoming a highly lucrative career field if you can definitely make a lot of money writing COBOL nowadays. Especially in the manufacturing and finance industries, you can't outrun all that infrastructure that was laid down decades ago. Legacy code permeates work all around the world. It'd be a huge mistake to ignore that old infrastructure and the languages tied to it.

With 200 billion lines of code laying around, it's going to be really hard to refactor all that. No, I don't think we'll ever see it disappear in our lifelines for sure. Chris Short is a Principal Product Marketing Manager at Red Hat. I want to drive Chris's point home for a sec. Consider this.

COBOL is baked into 95% of all ATM transactions. That's how tied we are to this language. And yet, the average COBOL programmer isn't much younger than the language itself. They're 45, maybe 55 years old. The newbies aren't interested, which is why I want to introduce you to someone. Hi, my name is Hrithika Trikka. Hrithika's a technology writer, formerly with HackerRank, and she's fascinated by this question of COBOL and the assumption people make that it's a kind of pointless leftover from the mainframe days. Developers today are really not thinking about COBOL. It's out of sight, out of mind. But that could be a recipe for disaster.

There's a huge volume of COBOL lines of code that are still powering businesses today. At least 1.5 billion new lines of code in COBOL every single year. And I think when you look at the specific industries, it's really interesting. Like, there's 50 million lines of code at the IRS. There's 60 million lines of code at the social security administration and so these businesses and entities are handling some of the most sensitive important information today and if we don't continue to power and maintain these mainframes it could be really disruptive. So if we can't escape our old infrastructure, and we can't wave a magic wand to rebuild the whole mainframe universe,

what do we do? How do coders, who sometimes only think about the future, start coming to terms with the past? We need to start by facing the problem head on. You know, younger generations are going to have to pick up these skills, or there has to be some sort of modernization of these mainframes. Either way, this problem isn't going to go away. That's why COBOL is relevant.

It's not going to be easy. Rithika figures we've ignored the problem for too long already. It's incredibly expensive, hard, and the risk is incredibly high to replace billions of lines of COBOL. It's mission-critical code, like social security and financial information. And COBOL was specifically designed for these types of large volumes of transactions. So it was designed for business transactions by Grace Hopper in the 60s. And if it's not broken, why try to fix it has been the mentality since the 60s. And now we're at

a point where we just have decades of very valuable, high volumes of data running on COBOL. In a way, Rithika's calling for a cultural shift, a change in attitude about what's in and what's out. As the world of development starts to actually gain a deeper and deeper past, we have to become more in touch with our own history. You can't escape the aging infrastructure. And that means you can't ignore the history of languages either. Something has to be done. You know, when I was at HackerRank, I saw firsthand how many banks and financial institutions are hurting and desperate almost for COBOL developers. It's not a problem that's going to go away. And I think either there has to be some sort of modernization of the

systems, or we need to keep training folks and incentivizing it. I personally think there's going to be a day where COBOL is actually in again. Really, what's going to happen when all of the developers with COBOL knowledge retire and no new younger generations of developers are learning COBOL? Something has to give, right? So there needs to be more of a systematic and institutionalized change when it comes to shifting away from COBOL and into the new cloud-based infrastructures. Rithika Trika is a technology writer

based in San Francisco. So what about those cloud-based infrastructures Rithika mentioned? Are the infrastructures we're building today going to chain future generations to particular languages, the way we're still tied to COBOL? Amazon Web Services, maybe the biggest single piece of cloud infrastructure, launched in 2006. Google Cloud Platform arrived in 2008. And Microsoft Azure started in 2010. The Go language, with its focus on concurrency,

was made to thrive inside all that new cloud infrastructure. It's a language of its time. Hi, my name is Carmen Ando, and I am a program manager for the Go team at Google. Carmen has an insider's understanding of how Go is tied to today's infrastructure. It starts with the creators of Go having some strong ties to the history of languages.

Robert Pike, Robert Griesemer, and Ken Thompson. Those names have kind of come through ever since the 1960s. So Ken Thompson invented the programming language B, and then he would go on to invent the Unix operating system on a summer off. And Rob Pike invented UTF-8, which is a string encoding. He also invented ASCII. He helped co-author the Unix programming environment. So these two had been co-workers for a very, very long time, and they had been looking at and inventing operating systems in previous programming languages, including C, which Ken Thompson would eventually help write with Dennis Ritchie.

Once Pike, Griesemer, and Thompson were all working at Google, they discovered a serious problem. Getting concurrency at scale just wasn't happening. People were waiting hours for a bill to compile. They were working in C++ and had to write all these callbacks and event dispatchers. It was 2009 and our infrastructure was changing again. Languages like C++ were becoming less and less in tune with that new reality. The problems were being introduced by

things like multi-core processors and networked systems and massive computation clusters and the web programming model. And then also just the growth of the industry and the number of programmers, which were going into the thousands and the tens of thousands by 2010. And so all the programming languages up until that point were being worked around rather than addressing things head on. Eventually, you reach a breaking point, and something's got to give. Hey, we hated C++, and we said, well, let's see if we could invent something new. That new language would need to be exquisitely adapted to our latest infrastructure. What happened with the cloud, which was starting to

come of age in 2005, was that you now no longer had to handle your own compute. You sort of are renting it elsewhere and you get a distributed system. But what happens in a distributed system and in a cloud is that you have problems of concurrent messaging between distributed systems. You need to make sure that you have no problems with asynchronously. Go is a programming language that is asynchronous by default. Basically, this means that every operation you perform, like sending all these different messages to another in the system, it's done without waiting for the other system to respond back to you. So it can handle multiple messages at any given time. And that said, cloud computing is distributed. And so Go was developed to address this exact need. Go became early on one of the standard ways of doing this kind of distributed computing. And that's why I think that it picked up a lot of the developer mindshare immediately. Go absolutely is the language of cloud infrastructure, both in

its design, but also in the ecosystem of all the cloud infrastructure tooling and building blocks that have sprung up in the last decade. Soon, major applications like Kubernetes were being written in Go. Google also created Go Cloud, an open source library and set of tools that made Go even more attractive. It became clear this was the language of a brand new ecosystem. It was the language of a brand new ecosystem. It was the language of the cloud. And it definitely didn't hurt that the creators had reputations for developing languages that lasted. I think that the rest of the industry said, hey, I don't think that this is going to be going away anytime soon.

And the inventors of the language also happen to invent languages that are now in their 50th year or 60th year. Carmen Ondo is a program manager for the Go team at Google. So we have a new language, Go, designed to deliver the concurrency that cloud infrastructure makes necessary. Sounds great. And Go's designers tend to create languages that last for a good half century. Also great. But my question is, what will that really mean 50 years from now when Go is more like COBOL? What will it mean when the world is teeming with legacy Go code that only older developers understand? Are we going to be prepared for a time when today's cloud infrastructure is aging? Are we learning lessons from COBOL and the world of mainframe

that could help us design a better future for Go and the cloud? Luckily, I found exactly the right person to ask all these questions. And that's next. How do we future-proof our languages? We know they're tied to the infrastructure of their day. And we know that new infrastructures are bound to replace the old ones as decades roll by. So what are we doing today to keep things running smoothly tomorrow? I'm Kelsey Hightower. I'm at Google. I'm a developer advocate,

and I work on bringing open technologies and turning them to products on Google Cloud. Kelsey spends a lot of time thinking about the future of programming. I was curious whether one day we're going to end up with another aging group of programmers with these wizard-like skills around Go, the same way we have a shortage of COBOL wizards today. Are we even planning for that long-range future? So Kelsey and I sat down to hash it out. But if you think about some of the new challenges today, things like dealing with the internet, the network,

you got multiple users, hundreds of thousands of concurrent users, different collections of machines and architecture types. So given those new use cases, typically you want to have a new language. For example, JavaScript is for the web. You don't want to retrofit COBOL so that we can start doing web programming with it. So we have hundreds of languages that are out and pretty well established today, and they're all kind of hyper-focused on their sweet spots. So in that case then, do we need to actively push people towards COBOL if we're developing

these new languages for these new problems, and they're highly specialized, and COBOL if we're developing these new languages for these new problems and they're highly specialized and COBOL's still sticking around? Do we need to encourage folks to pick it up so we can maintain our legacy code? Well, I think that's going to be a challenge for the enterprise, right? So you've invested 10, 20 years in COBOL and there is no one actively thinking about learning some new COBOL, right? You don't come out of college just like, I'm going to double down on this language that's older than my parents. So in that world, you have to ask yourself, what is the risk of continuing on with COBOL? Is it still relevant going forward?

I think it is still relevant for certain types of workloads, but we have to ask ourselves a question, is it time to progress? Is it time to evolve a little bit? So if you still have billions of lines of COBOL, yeah, you're in the situation where you're going to have to try to find all the COBOL talent that's remaining and bring them in-house. But maybe we start to think about what can other languages learn from COBOL and incorporate some of that functionality and libraries into other languages. Life after COBOL. That would be an enormous infrastructure project all on its own.

To use my New York subway analogy, it'd be like replacing every underground tunnel. So going forward, I wanted to know whether we could anticipate those issues and even do our future selves some favors. If we compare the cloud today to mainframes, are we going to end up in the same boat where we have these legacy code bases that are using kind of old but very stable languages and we have to kind of reach this new point of figuring out if we should move on or stay the same? So the thing that makes the cloud a bit different, it's not from one manufacturer, right? A lot of cloud providers typically bundle up collections of technology so you have your choice of programming language,

you have your choice of programming paradigm, where you want to do event-driven or it's all web services based on HTTP. So what that means is you get to choose what you want to program in and just kind of focus on what gets solved. So data will come in, data will come out, but you choose how you want to process that data. The mainframe typically just kind of had one main interface, right? Like you write this job and this is how you submit the job. Here's how you monitor the job and here's where it comes out. So that's very limiting in and of itself. So if you think about some of the newer mainframes, they also support some of the newer technology.

So even in the world of mainframe, you start to see the expansion of programming languages you can use to run your jobs. So then we start to ask ourselves, okay, given that I have my new choice, when is it time to move on from this particular programming paradigm? So I think we don't get stuck, but I think it is going to be nice that there's going to be a new machine that's going to be distributed. Maybe there's a lower cost of entry. You don't have to buy the whole mainframe to get started, but we still want that ease of use of, here's my job. You run it for me. tell me when it's done. Absolutely. Do you see what's happening or what's happened to COBOL happening to any of today's languages?

Like, for example, Go. Do you see us struggling to maintain Go and getting folks who want to write Go in 30 years? I think all languages can suffer that fate, right? So if you think about it, Python's been around for a very long time. I think it's close to 20 years, if not more. So I think what happens, and Python's had a resurgence in its usage, right? It's kind of the foundational language for machine learning, for libraries like TensorFlow. So if we use just time alone, I think that's probably not the right way to look at it. How relevant is that community? How relevant is that language willing to adapt? And I think what Python did really, really well,

that community saw the ability to make other languages easier to use. For example, TensorFlow has a lot of C++ underneath it. So programming in such a language is probably not as user-friendly as something like Python. And you can take Python and use it to generate some of the stuff

that people are using, for example, TensorFlow. Now that machine learning is hot, people have brung Python into that new space, so guess what? Python continues to be relevant and will be relevant for some time to come. The same thing is going to be true for Go. If Go can continue to be relevant,

it's like at the foundation of many of our infrastructure tools, many of the cloud libraries, it too will remain relevant. So I think it's all about those communities ensuring that they have a place in the future. And when the future shows up, making sure that they have a story there. Yeah. So how do we future-proof our languages? Meaning, how do we intentionally design a language to make it last and make it relevant 20, 30 years from now? The people that use the language, so this is something that's really unique, I think, in the open source space. Now that we've moved away from commercial languages, right? Languages used to come from Microsoft or Sun Microsystems in the case of Java. And at that point, everyone relied on the vendor

to do all the heavy lifting about what the language would be able to do, any new improvements in the runtime. Now what we see with things like Go, Node.js, Ruby, all of these are community-backed and focused runtimes and languages. So anyone can add new libraries. There was a new HTTP spec. HTTP 2 came out a few years ago,

and each of the respective communities just had contributors at those particular libraries, and now guess what? All of those languages are now compatible with the future of the web for the most part. So I think it's really now that individuals have more control if they want their language to be relevant for new use cases by just contributing that functionality themselves.

So we're not restricted to one or two companies. If the company goes out of business, then maybe the runtime dies with it. We don't have that problem as much anymore. We've said it on this podcast before. The future is open. But it's fascinating to consider how, in another couple decades, the past will be open too. They'll be inheriting infrastructure and languages that are able to morph and evolve.

Awesome. Thanks for having me. And I look forward to what people do. And mainframe is still relevant. So we don't call it legacy. These are classic technologies. Ooh, I like that. Classic. Very nice. Kelsey Hightower is a developer advocate at Google. I'm imagining a future that's rich with classic programming languages, along with new languages that haven't even been born yet.

That's a future I'm excited for. You know, in 2017, Governor Andrew Cuomo declared a state of emergency about the New York City subway. His government set aside $9 billion to invest in the aging infrastructure. And that should remind us, sooner or later, we have to take care of the systems we inherit. You don't just race onward to whatever comes next. You bring the past with you. In the world of development, we tend to have a bias towards the future. We think our languages are only useful in the moment when they're the hot new thing. But as informational infrastructure

continues to age, the history of development becomes more and more real. The past, it turns out, isn't past at all. And it's our job to remember that. You can learn more about COBOL or Go, or any of the languages we're covering this season, by heading over to redhat.com slash command line heroes. There's a bunch of

great bonus material waiting for you. Next episode is all about Bash. We're exploring the origins of shell scripts and the key to automation. Command Line Heroes is an original podcast from Red Hat. I'm Saran Yitbarek. Until next time, keep on coding. Hi, I'm Jeff Ligon. I'm the Director of Engineering for Edge and Automotive at Red Hat. Thank you. containers are a big part of the future vision of software-defined vehicles. And look, if we can get the container revolution to work in cars, then everything a cloud-native developer can do today can apply to cars. This huge ecosystem of engineers can start to write applications for automotive.

We can completely change the industry. This is why Red Hat's open-source approach to edge computing is so important. The way we collaborate, the way we build together, it's already making some pretty incredible things possible. Learn more about them at redhat.com slash edge.