Skip to main content

The Tower of Babel: A Tale of Ones and Zeroes

Within a decade, the idea of a single, monolithic approach was demolished as LISP, COBOL, RPG, BASIC and even the first incarnation of C all became pervasive.

illustration of people coding

Sixty years ago. computing was easy. FORTRAN was the only commercially available programming language and most people in the field knew it. But within a decade, the idea of a single, monolithic approach was demolished as LISP, COBOL, RPG, BASIC and even the first incarnation of C all became pervasive. And the diversity of languages and tools has only increased since then. This has created an alphabet soup for developers struggling to stay ahead of the curve. And it’s also made companies increasingly vulnerable to the dreaded skills gap where there aren’t enough people to work in the latest programming languages.

In theory, having dozens of languages is a good thing. After all, being able to create and manage code as efficiently and effortlessly as possible (not to mention, easy debugging) is a great way to drive value. The problem is that people who are fluent in one modality aren’t necessarily up to speed on the latest developments in other languages. As a result, programmers, administrators and engineers need to constantly learn new skills so they can be ready for the next big thing. That’s not always easy. It can be hard to fit in new technical training when your schedule is already stretched to the breaking point.

Unfortunately, the world (including your boss and customers) doesn’t care if you’re busy. As a result, even if you don’t have time to learn a new language, you still have to do it. What if programmers could develop in whatever technology they choose while still accessing all the functions built into existing enterprise applications?

It's possible. And it all comes down to interfaces that let users program in whatever languages they know and prefer instead of traveling back 30 years to learn RPG or COBOL.

The Open-Source Solution

The answer is service enablement and open-source user experience design. Creating a framework that facilitates multiple languages allows for more influences and styles to be utilized to improve user experiences more quickly with less effort and money per change. If users can program in their preferred languages, they need less training and less time to transition from being competent to skilled. Not only that, but far greater flexibility is inherent in that framework to adapt to the many and varied evolutions required for future success.

The first key aspect of this open-source design is service-enabled IBM i application functions. These functions are critical to promote the open-source nature of the design space, introducing new possibilities for designers looking to improve or add to the capabilities of the framework.

Second, creating workflows that incorporate your business needs and goals into your APIs is critical for coalescing the efforts of users into the optimized business solution that you need. Having access to the multitude of APIs in various styles is only as useful as their application to your business strategy, and careful direction in the aggregation process is necessary to prevent this new access from overwhelming you.

Lastly, this solution is necessary for the management and modification of the APIs over time. The intense modernity embodied by a collection of APIs carries an inherent need to evolve that collection, taking advantage of the ability to change and optimize as time goes on. This isn’t a plug-and-play strategy, and consistent updates and small alterations ensure your framework remains perfectly tuned to your needs. After all, the only way to keep finding the aspects of your perfect user experience is to keep looking for them, because they are most certainly out there.

Why It Matters

All of this might seem theoretical, but it all comes back to real-world benefits. New applications are being written all the time, often in languages like Node.js, Google GO, Python, and more for web, mobile, Internet of Things, etc. These languages deliver the user experiences that people want, providing the colorful minimalism that’s driving a lot of the most popular designs. Failing to implement the kinds of advances that these languages can offer makes your job a great deal harder in ways it simply doesn’t have to be.

Many IBM i applications were written in RPG and COBOL for green screens and it takes a lot of development effort to turn them into attractive modern interfaces. If you want to focus on the user experience, the first step is to find a way to connect modern programming languages back to IBM i application code. Once you navigate that challenge, that code needs to stay connected to the modern languages you’re using to create your updated user experience. Not thinking this through on a programmatic basis could become a maintenance nightmare, especially given the limited back-end knowledge available in the market.

Computing has changed a great deal. Instead of being able to do everything you need to do in a single language, dozens of languages are all being updated constantly. Creating an open-source framework that allows for programming in the languages users are most familiar with is an answer that de-emphasizes any potential confusion or necessity to learn COBOL for IBM i applications. This allows for the kind of popular user experience constructed by contemporary languages that can handle the kinds of advances and modifications that provide an equally contemporary workflow.

If you can service-enable your application functions, create application workflows that fit your business strategy, stay on top of your API management, and create a solid connection between those modern languages and your original green-screen applications, you can change your applications for the better. Create an open-source solution and let your developers stay on top of everything for you.

IBM Systems Webinar Icon

View upcoming and on-demand (IBM Z, IBM i, AIX, Power Systems) webinars.
Register now →