This blog describes five misconceptions re Mainframe modernization – http://openlegacy.com/rethinking-mainframe-modernization-top-5-misconceptions. I agree that it is a common misconception that the mainframe can’t handle the new ‘fancy’ applications that are the rage. If it is used correctly, there is no reason that the mainframe can’t be part of a new application – especially if the hardware and software already exists.
Here is a copy of that blog entry:
Rethinking Mainframe Modernization: Top 5 Misconceptions
With all the lip service paid to making business apps more mobile or accessible from the cloud, many mainframe owners are starting to feel left out. That’s because they still believe that modernizing legacy applications is extremely expensive, time consuming and fraught with risky technical challenges. With that kind of thinking, it’s no surprise that legacy systems are considered outdated.
In truth, these archaic ideas are keeping companies from extending the value of highly reliable systems into the modern world. Today, I’m here to address a few of these misconceptions and hopefully provide some tips for immediate consideration:
#1. I need all new hardware before I can start
With vendors constantly touting the flexibility of virtualized, software driven environments, many now believe that only a complete “replatforming” effort will support modernization. That’s just not true. Companies can actually leverage the innovations that inspired that shift to develop software-based, API-driven apps that efficiently access data and functions on legacy systems – solutions which can then be fully accessible via a mobile, web and/or cloud-based interface.
By eliminating artificially created hardware barriers, companies can focus instead on making technology serve the business – as opposed to serving itself.
#2. Open source cannot be coupled with legacy systems
Unfortunately, many still believe that the proprietary nature of legacy systems makes it impossible for them to coexist with open source solutions. While programmers cannot use HTML5, Java, .NET, PHP to write applications that actually reside on the mainframe, they can be used to develop modernized apps themselves. By employing REST APIs, developers can easily bridge legacy and open source IT environments – in this model the mainframe will look like any other data source on the network. Its information can accessed, updated and enriched by any mobile device, connected system or cloud-based application.
#3. Web-based access to mainframes will always be slow
Most applications originally designed to bring legacy capabilities to the web utilized complex middleware schemes and/or pieces of existing mainframe COBOL code to emulate functions online. Additionally, many of them used HTML web emulation techniques which are now incompatible with today’s browsers. Either way, response delays seemed to be built into those applications from the start.
However, that does not have to be the norm today. Uncomplicated designs coded in Java that use APIs to streamline backend connectivity eliminate many communication delays. When coupled with connection pooling technology, this approach ensures millisecond responsiveness.
#4. Legacy systems can never keep pace with evolving needs
Regardless of environment type, it takes a lot of work on the part of IT to continuously adapt to changing business requirements. Most understand that agility does not reside in a specific technology – instead it’s about designing processes that easily leverage the value inherent in all available assets.
For instance, companies have always relied on mainframes to maximize uptime. However, they also understand that the difficulties inherent in developing new features and integrating with other systems are so great that they severely limit IT responsiveness. Rather than forcing a system upgrade to a less stable hardware platform, companies can “update” their approach to application development. Instead of creating mainframe applications natively, companies can switch to creating applications that run “on top of” legacy systems. By moving to lightweight programming languages such as Java, companies can cut application development time by as much as 80%. Using APIs instead of middleware will eliminate many of the delays that haunted modernization projects.
When technical barriers are removed from the equation, IT groups can quickly respond to a wide range of business requests. In fact, companies that effectively leverage application development shortcuts can often prototype new solutions in just weeks – all without having to rebuild the infrastructure each time the business needs something new.
#5. We don’t have the budget
In the past, legacy feature requests or system integration work came at an exorbitant price. Worse, a good percentage of these projects failed after extensive time and staffing investments were made.
Many companies fear that this is still the case and actually refuse to investigate their options. In truth, today’s open-source techniques for extending mainframe capabilities can be delivered at a fraction of the cost most expect. After all, they require significantly less coding /integration work and infrastructure related expenses are minimal. For most, this method will actually lower Total Cost of Ownership – often by as much as 75%.
All of these misconceptions have combine to make the terms “legacy” and “modernization” seem perpetually incompatible. Today, IT advances have actually eliminated many of the barriers that previously kept companies from extending mainframe functionality and embracing the new opportunities that mobile, web and cloud environments offer. I trust those reading this piece will no longer count themselves as members of that group.