As we enter a new year, it’s only natural to look back on what we accomplished in the past 365 days. Many of those accomplishments centered around explaining what TSRI does in a way that nearly everyone can understand. Software modernization and refactoring solutions are, by their very nature, complex concepts. Teams of specialized engineers are required to successfully complete each project, and even the simplest automated transformations can take months to get all the right pieces put into place.

In this blog, we highlight some of the most informative pieces published in 2021. These materials were designed to help make the automated modernization process easier to understand and navigate from start to finish. We hope you’ll find them useful as you consider your organization’s IT plans and modernization initiatives for the coming year.

GETTING READY TO MODERNIZE!

Modernizing to the Cloud 
Scott Pickett, TSRI’s Vice President of Product Operations and Service Delivery, conducted a live presentation that discussed how automated modernization can help organizations move their applications to the cloud. The presentation resulted in a complete series of videos, all of which are accessible from the post linked above.

Check out this article featuring a downloadable Checklist: Preparing for Cloud Modernization to help you assess your organization’s current assets, including your existing codebase, databases, and other tools that may be installed on your mainframes and other legacy technologies.

MODERNIZE WITH LESS DISRUPTION

One of the major risks of any modernization is the amount of time a system will be taken offline during cutover to the new environment. Any downtime becomes a disruption to the business, whether that means lost revenue or maintaining security of mission-critical systems. This post, 4 Tips for Modernizing with Minimal Business Disruption discusses ways that organizations can mitigate disruption, and also explains how proofs of concepts, step-wise automated migrations, and proper planning play into maintaining continuous uptime.
 

Common Misconceptions About Modernization (And What to Do About Them)
Application modernization is a game changer in any organization. Oftentimes, perceived obstacles, such as prolonged system downtime, get in the way of bringing mission-critical applications to modern programming environments. This article helps to dispel many of those notions.

Automated Refactoring: The Critical Component to Achieving a Successful Modernization
When any application gets modernized, the codebase shifts from a legacy language such as COBOL or PL/1 to a modern language such as C# or Java. However, just because the language is up to date doesn’t mean the system will operate more efficiently. That’s why refactoring is so important: this automated, iterative process eliminates dead code and redundancies while streamlining the entire application. It’s truly the key to more secure, robust applications.

Microservices Offer Robustness and Security in Modern Systems
Many, if not most of the clients who modernize their mainframes with TSRI started out with monolithic systems. All functions in the workflow relied upon one another, and if one area went down, the entire system went down. Modern software architecture operates using multiple tiers that interoperate with one another, but aren’t dependent on each other. That means if one area goes down, the entire system doesn’t go down with it. A component of this structure, known as microservices, makes for easier software maintenance and also protects organizations while allowing for faster go-to-market strategies for new applications.

Cloud Migration and Containerization: 3 Steps to Reduce Risk and Ensure Success
An important benefit to automated modernization is how the business logic of the transformed application never changes. Sometimes, particularly when modernizing to the cloud, the legacy application may still require some usage. Rather than keep the mainframe in operation or employing some other inefficient, insecure method, transforming to a containerized modern codebase can keep those application instances separate from the rest of its processes. This method increases security and efficiency while allowing for further system development in modern languages.

As you contemplate modernizing your mainframe or embedded-system applications in the new year, we hope these articles will provide you with the knowledge you need to move forward.

Mainframes are big. Mainframes are powerful. Mainframes continue to run an enormous number of critical applications. Even as today’s enterprise infrastructures gravitate toward the cloud and newer languages, according to Allied Market Research, the market for mainframes will continue to grow through at least 2025 and legacy languages such as COBOL are still in wide use. The actual amount of processing performed by mainframes continues to grow steadily each year as a result of increasing demands, more users, and new applications reliant upon data stored on mainframes.

Modernize Now, Plan for the Future

While the capacity and processing power of a mainframe remains attractive to enterprise companies and governments alike, there are drawbacks: when it comes to agility, mainframes cannot quickly adjust to the needs of a business. They cannot quickly scale to meet extraordinary events. It’s difficult to integrate business-intelligence tools for non-engineers to easily access the data they need. Mainframes often don’t have the automated security tools to mitigate a security breach before it causes extensive damage.

At the same time, as each year passes, more experts that can maintain the older, legacy languages like COBOL and PL/1 are retiring. In the wake of the Covid-19 pandemic, the availability of programmers reached crisis proportions when overtaxed unemployment systems in some U.S. states couldn’t keep up with demand. Most younger software engineers train and work in newer, evolving languages that support web technologies and the cloud.

Still, even as many of these enterprise organizations are strongly considering moving operations and processes to the cloud, such migrations can take years, and they may not abandon their mainframes entirely. But they still need the agility, access, and security of a modern system to remain competitive.

So, what can these organizations do? They can modernize.

A modernization effort is often targeted not only at the mainframe itself, but at older language programs that run these massive machines. These programs, often written in now-archaic languages without consideration for internet connectivity or cloud computing, often need to change to meet the organization’s current needs for accessibility, customer experience, and security compliance. These requirements are universal to modernization efforts of any kind, but not all forms of modernization are adept at meeting all the requirements. The modernization strategy your organization selects needs to consider the resources you have available, your timelines, and what your ideal outcome looks like.

Choosing a Modernization Strategy

Mainframe modernization does not have to mean eliminating the mainframe. Organizations can utilize a number of different modernization strategies that meet different demands at varying cost and risk levels. Some possibilities include:

1. Gradual integration: On an as-needed basis, organizations can use automation to modernize older applications through incremental improvement and build new applications on the mainframe that fit into a state-of-the-art computing environment.
2. Retire, Retain, Replace, Rehost or Re-envision: An organization will assess legacy applications and systems on an individual basis and decide what should be retained, what can be rewritten, and what should be replaced with a new, modern application that can be hosted in a new environment such as the cloud.
3. Lift and shift: Rebuild current mainframe applications on a new platform, then integrate the with mainframe applications and data sources across platforms.
4. Automated Transformation:  A dedicated team assesses existing applications created in common languages such as COBOL or Fortran, or even less-common languages like PL/1 and MUMPS, then uses automated processes to translate the legacy application to the desired modern language (e.g., Java is a very common target). Organizations can then migrate to an upgraded mainframe or rehost them in the cloud. At the same time, a wider range of programmers can work with the modernized applications and more easily incorporate them into new databases and services.

Each approach varies depending upon business requirements, budget, and modernization schedule. Regardless, before beginning any process, an organization’s business and technical teams need to define their objectives and scope.

Gain Security & Competitive Advantage

Whether your organization is ready to move out of a mainframe environment or not, modernized code provides the security and peace of mind that your critical applications can be maintained and evolved as needed to support the business over time. As the Covid crisis and associated economic pressures have forced businesses of every size to accelerate modernizing their legacy systems, organization leaders have realized they can no longer wait to maintain their security and competitive advantage.

While some organizations may choose to do a wholesale migration, most companies and government agencies will opt to modernize using a more gradual approach. Either way – and whether an organization stays on their mainframe, moves to the cloud, or develops a hybrid solution – a modernization will ensure they can have the digital and human resources to sustain their operations far into the future.

-----

TSRI is Here for You

As a leading provider of software modernization services, TSRI enables technology readiness for the cloud and other modern architecture environments. We bring software applications into the future quickly, accurately, and efficiently with low risk and minimal business disruption, accomplishing in months what would otherwise take years.

See Case Studies

Learn About Our Technology

Get started on your modernization journey today!

Using automation to modernize mainframe applications will bring a codebase to today’s common coding standards and architectures. But in many cases, modernization to an application’s functional equivalent isn’t always enough. Organizations can do more to make their modern code more efficient and readable. By building refactoring phases into their modernization projects, organizations can eliminate the Pandora’s box of dead or non-functional code that many developers don’t want to open, especially if it contains elements that just don’t work.

Using TSRI’s automated refactoring engine, remediation was complete in an hour.

What is Refactoring and How is it Used?

Refactoring, by definition, is an iterative process that automatically identifies and remediates pattern-based issues throughout a modernized application’s codebase. For example, unreferenced variables or unnecessary redundant snippets could exist throughout the application. This scan, known as dead/redundant code refactoring, will find repetitions of any of this unusable code to flag, then remove it from the codebase. One of TSRI’s current projects found 25,000 instances of a similar issue that would have required 15 minutes of manual remediation per instance—not including the inevitable introduction of human error that would require further remediation. The number of development hours would take more than a year for a single developer to complete.

Using TSRI’s automated refactoring engine, however, remediation was complete in an hour.

Calling refactoring its own post-modernization phase is, in some ways, misleading. Refactoring typically occurs all the way through an automated mainframe transformation. As an example, in a typical COBOL or PL/1 mainframe modernization, TSRI would refactor the code from a monolithic application to a multi-tier application, with Java or C# handling back-end logic, a relational database layer through a Database Access Object (DAO) layer, and the user interface (screens) modernized in a web-based format. Believe it or not, many legacy applications still run on 3270 green-screens or other terminals, like in the graphic below.

Once the automated modernization of the legacy application is complete, the application has become a functionally equivalent, like-for-like system. However, any deprecated code, functions that may have never worked as planned, or routines that were written but never implemented will still exist. A process written in perhaps 1981—or even 1961—may have taken far more code to execute than a simple microservice could handle today.

Situations like this are where refactoring becomes indispensable.

Where to begin?

Before a formal refactoring process can begin, it’s important to understand your goals and objectives, such as performance, quality, cybersecurity, and maintainability. This will typically mean multiple workshops to define which areas of the modernized codebase need attention and the best candidates for refactoring, based upon the defined goals. These refactorings will either be semi-automated (fully automated with some human input) or custom written (based upon feedback from code scanners or subject-matter experts.)

The refactoring workshops can reveal many different candidates for refactoring:

• Maintainability: By removing or remediating bugs, dead or orphaned code, or any other anomalies the codebase can be reduced by as much as one third while pointing developers in the direction of any bugs in need of remediation.
•  
• Readability: Renaming obscure functions or variables for a modern developer to fit within naming conventions that are both understandable and within the context of the code’s functionality.
•  
• Security: Third-party tools such as Fortify and CAST can be utilized to find vulnerabilities, but once found they need to be remediated through creation of refactoring rules.
•  
• Performance: Adding reusable microservices or RESTful endpoints to connect to other applications in the cloud can greatly improve the efficiency of the application, as can functionality that enables multiple services to run in parallel rather than sequentially.

What are the Challenges?

• Challenge 1: One reason refactoring must be an iterative process is that some functionality can change with each pass. Occasionally, those changes will introduce bugs to the application. However, each automated iteration will go though regression testing, then refactored again to remediate those bugs prior to the application returning to a production environment.
•  
• Challenge 2: The legacy architecture itself may pose challenges. On a mainframe, if a COBOL application needs to access data, it will call on the entire database and cycle through until it finds the records it needs. Within a mainframe architecture this can be done quickly. But if a cloud-based application needs to call a single data record out of millions or billions from halfway across the world (on cloud servers), the round trip of checking each record becomes far less efficient—and, in turn, slower. By refactoring the database, the calls can go directly to the relevant records and ignore everything else that exists in the database.
•  
• Challenge 3: Not every modernization and refactoring exercise meets an organization’s quality requirements. For example, the codebase for a platform that runs military defense systems is not just complex, it’s mission critical. Armed forces will set a minimum quality standard that any transformation must meet. Oftentimes these standards can only be achieved through refactoring. A third-party tool like SonarQube in conjunction with an automated toolset like TSRI’s JANUS Studio^® can be utilized to discover and point to solutions for refactoring to reach and exceed the required quality gate.
•  

In conclusion, while an automated modernization will quickly and accurately transform legacy mainframe applications to a modern, functionally equivalent, cloud-based or hybrid architecture, refactoring will make the application durable and reliable into the future.

--

TSRI is Here for You

As a leading provider of software modernization services, TSRI enables technology readiness for the cloud and other modern architecture environments. We bring software applications into the future quickly, accurately, and efficiently with low risk and minimal business disruption, accomplishing in months what would otherwise take years.

See Case Studies
Learn About Our Technology
Get started on your modernization journey today!