Let's talk about Modernization! Call +1 (425) 284-2770 or send us a Message!


Friday, 20 November 2020 09:22

Modernization to AWS

Quickly Modernize Your Mainframe Technology for AWS

Migrate to the cloud faster with TSRI's reusable process and scalable solution


Seamlessly Migrate Valuable Mainframe Technology with TSRI's AWS-Certified Engineers and Architects

As an AWS partner, TSRI's certified engineers and architects get mainframe software into the cloud quickly leveraging our automated refactoring technology. Our near-100% automation process transforms legacy applications to Cloud native applications ready for deployment on AWS. Our model-based solution transforms even very large (tens of millions of lines of code) legacy systems written in languages like COBOL, Fortran, PowerBuilder, Ada, MUMPS, VB6, and more than 25 other languages, into modern applications in cloud native target architectures. The output is a multi-tier application, taking advantage of cloud utilities and scalability.

TSRI's Migration to AWS Cloud

TSRI has extensive experience in all forms of legacy code transformation, including migration to cloud services and containerization. TSRI can move the currently-modernized applications to the cloud using cloud-specific refactorings – targeting services, micro-services, and containerization. Our migration services take a three-step approach:


Migration of legacy monolithic code to a service-oriented environment. This includes updating language from COBOL to Java or C#, changing databases, and refactoring to enable microservices. This step begins the process of abstracting underlying services from the application.


Integration of service-oriented applications with native cloud services. This could include re-orienting code from, for example, WebSphere DB2 legacy platforms to Apache Tomcat and Amazon RDS. Upgrading to incorporate the latest native architectural interfaces ensures that applications are tightly integrated with the new environment, and ensures easier updates in future.


Transformation of native cloud to Docker Containers. The movement to containers provides additional architectural abstraction and improved integration of applications within the cloud.


AWS Sample Target Stack

TSRI has already modernized many Mainframe applications directly to the cloud for quite a few customers! Below you can find a sample target stack that we have modernized to and deployed in the cloud. Here the application was refactored to utilize a MVC style architecture, introduced a RESTful layer and modularized, as well as, containerize the application itself. While this is a sample technology stack that we can immediately go to, we are happy to adapt our solution to fit your needs and requirements.

AWS Sample Reference Architecture

Below you will find a sample architecture diagram for some of the modernizations we have undertaken going to AWS. Here you can see that we implemented REST endpoints to expose online programs for legacy interfaces, such as CICS. Such REST endpoints also expose batch to Python client job, XDML and ETF files. Our Database Access Object (DAO) injection supports data servers and the ability to talk to the source database & target database (for example, DB2 & SQL Server on AWS Aurora at the same time - this allows for step wise go-live for not only parts of the application but also parts of the database and even users. This solution helps reduce risks and makes the go-live easier for our customers. 

When one goes from a Mainframe single monolithic architecture & environment to a multi-tier architecture distributed environment, performance issues are exposed at the I/O via profilers and then remediated via TSRI's refactoring capabilities, high-performance modern environments and also other technologies such as caching capabilities in the new modern environment (here you can see that REDIS cache addressed rountripping data access and scalability.

AWS Cloud Case Studies

For over 25 years, TSRI has focused on modernizing the world's most critical technology. From retail and financial systems to mission-critical military applications, TSRI has completed over 250+ projects including modernizations targeting private and public cloud architectures. We are pleased to bring our experience to AWS cloud migrations, and have achieved success on every past project with references available.



Case Study

United States Air Force SBSS ILS-S COBOL to Java on AWS Modernization

A major component of the system is 54 years old, written in COBOL, and provides retail-level business logic. The component runs on mainframes that have proven to be extremely difficult to change and manage, and the DoD needed to modernize the component to drive down operating costs and move to an open platform, while retaining all functionality....

by Phil de Valence, AWS

On behalf of a U.S. Department of Defense (DoD) client, our multi-company team—comprised of staff from ARRAY, NTT Data, TSRI, and Datum—delivered a successful modernization of a COBOL-based system running on aged mainframes to a Java-based system running on x86 Red Hat Enterprise Linux (RHEL).

The goals were to introduce agility, reduce costs, modernize the technical stack, and enhance security by leveraging Amazon Web Services (AWS). We did this using automated code conversion tools and techniques while maintaining all functionality, screens, and reports.

The modernization target was AWS GovCloud (US) in order to address the DoD’s stringent security and compliance requirements such as U.S. citizenship.

The system we modernized is an ACAT III Major Defense Acquisition Program and mission-critical system used by more than 18,000 users at over 260 global locations. It provides daily supply chain and equipment support for DoD missions and is the accountable data system for over $30 billion in inventory.

AWS provides the system’s capabilities for reliability, scalability, and availability with features such as Availability Zones (AZs), Auto Scaling Groups, and Amazon Relational Database Service (Amazon RDS).

In this post, we describe the objectives, approach, solution, lessons, and customer benefits realized from this experience. ARRAY Information Technology is an AWS Partner Network (APN) Standard Consulting Partner.

Context and Objectives

A major component of the system is 54 years old, written in COBOL, and provides retail-level business logic. The component runs on mainframes that have proven to be extremely difficult to change and manage, and the DoD needed to modernize the component to drive down operating costs and move to an open platform, while retaining all functionality.

In the past, attempts made to modernize the component failed due to the massive size and complexity of the task. In fact, modernizing the component was regarded as such a difficult task that it was highlighted in the 2003 book Modernizing Legacy Systems: Software Technologies, Engineering Processes, and Business Practices.

After 54 years of operations, maintenance, and extensions, the component’s code had become poorly documented. The technical design of the existing system, which was needed to support the modernization effort, had to be derived from the existing system and code.

Key characteristics of this component included:

  • Annual operating costs over $30 million, largely attributable to mainframe hosting and maintenance costs.
  • 1.3 million lines of COBOL Source Lines of Code (SLOC).
  • A data management system, comprised of 1.2 million lines of COBOL code, supporting approximately 500,000 transactions per day.
  • Few remaining subject matter experts (SMEs).
  • Difficulty finding qualified, affordable COBOL programmers.

The component needed to be modernized and migrated to an affordable open system and hosting environment, with no down-time, data loss, functionality loss, performance loss, and minimal mission risk. The DoD had never done anything like this.

Modernization Approach and Solution

Our team developed a trusted relationship with the DoD’s Project Management Office over several years by delivering solutions that transformed and improved their supply mission. In 2015, the DoD contracted our team to modernize the component to become an integrated and sustainable part of the overall system.

We started the project by identifying and evaluating solution options:

  • A total manual rewrite and re-architecting solution failed to meet the program’s time constraints, had historically low success rates (high risk), and would have been too costly.
  • A replacement solution was not selected because the DoD needed to retain all the current business rules.
  • A COBOL emulator re-host solution was a stopgap measure that failed to reach the J2EE/RHEL/SQL DB architectural future state requirement.

This analysis led to our decision to use a COBOL-to-Java code automated refactoring solution. This option would take a low-risk, incremental approach and apply a blended agile/traditional methodology and tools to ensure rapid, high-quality software delivery.

Component Modernization Phases

Once the COBOL-to-Java code automated refactoring solution was selected, a three-phase approach emerged to meet the entirety of the DoD’s requirements and cost, schedule, and risk constraints.

  • Phase 1 (18 months): COBOL-to-Java code automated refactoring to x86/RHEL platform 
    This was the most complex and risky phase, as we automatically refactored COBOL code from mainframes to Java code on a virtualized x86 RHEL platform while not losing any functionality or performance. The resulting Java code contained design remnants of COBOL, and development and test environments were moved to the AWS Cloud.
  • Phase 2 (12 months): Code advanced refactoring to remove COBOL design overtones 
    We refactored the Java codebase even more to remove residual COBOL remnants, overtones, and design elements to improve maintainability.
  • Phase 3  (3 months): Infrastructure moved to AWS GovCloud (US)
    We moved all remaining environments to AWS GovCloud (US) including staging and production. AWS GovCloud (US) allowed us to meet the many cyberthreat security requirements for the DoD.

Figure 1 shows our three-phrase modernization approach. The two Java logos illustrate the different Java phases. At the end of Phase 1, the Java program is “dirty” with remaining COBOL coding practices. At the end of Phase 2, the Java program is “clean” without COBOL remnants.


Figure 1 – ARRAY’s three-phase modernization approach met the DoD’s stringent requirements.

Phase 1: Automated Refactoring of COBOL to Java on x86

The modernization of the component involved a conversion of 1,260,679 lines of COBOL code and 10,078 lines of C code to Java to maintain current application capabilities, Graphical User Interface (GUI), and performance while migrating to an affordable and sustainable x86 RHEL platform.

The component’s COBOL online and batch applications were automatically refactored to run on a JEE platform using Java object-oriented software layers (data access, presentation, business logic) and patterns to enable migration to a standard x86 architecture.

The modernized Java software reused identifier names from the original COBOL application, allowing the component SMEs to read and understand the new Java code and routines more easily.

Rather than simply transliterating source COBOL code to target Java code, the tool executes a mature automated conversion and refactoring process by first constructing a comprehensive Intermediate Object Model of the legacy system in an intermediate translation language.

Once modeled within the tool engine, SMEs employ an iterative process of applying rules and tuning to output the transformed code into the target Java language.

We completed the work of reintegrating items like schedulers and other utilities, testing the initial construction iterations of the code, and providing defects. In response to each construction delivery evaluation, we adapted the transformation rules and regenerated improved construction iterations of the code according to internal evaluations.

During this phase, the COBOL Data Management System network database code was transformed to COBOL with SQL. This COBOL and SQL code was then transformed to Java and SQL code.


Figure 2 – The component COBOL automated refactoring to Java.

Phase 2: Advanced Refactoring to Remove COBOL Design Overtones

After we completed Phase 1, the resulting converted Java code contained COBOL paradigm design remnants, or COBOL overtones, that required personnel to have specialized skills to maintain the codebase. A plan was developed to identify and correct COBOL overtones with standard Java solutions. This part of the effort was considered low-risk because we used approaches, processes, and techniques proven in Phase 1.

Our refactoring approach used the TSRI JANUS Studio tool and a semi-automated refactoring method that performs further code optimization, naming changes, and other enhancements to improve architecture, design, security, sustainability and performance.

We used an iterative approach consisting of tool-driven automated refactoring, regression testing, and customer review to address the four most significant COBOL overtones existing in the component’s Java codebase:

  • Refactoring the COBOL Memory Model to Java
  • Refactoring the COBOL data mapping layer to native Java and SQL
  • Removing COBOL-style control-flow/GOTO Logic
  • Identifying and removing redundant code sections

These techniques, along with the improved method synthesis algorithm, greatly improved the maintainability of the Java codebase.


Figure 3 – The component refactored to maintainable Java.

Phase 3: Infrastructure Moved to AWS

After Phase 2 was completed, the entire component was moved to AWS GovCloud (US) including the staging, production, and all support environments.

AWS GovCloud (US) was selected because it aligned with the future technical direction of the system. This included cybersecurity, DevOps, and automated continuous integration (CI) and continuous delivery (CD) tools. The component’s architecture was installed in AWS GovCloud (US) and continues to evolve.


Figure 4 – The component moved to Amazon Web Services (AWS).

Customer Benefits

For the DoD, the component has been transformed from an expensive mainframe COBOL legacy system to an affordable, modern maintainable Java-based system. All valuable existing business rules have been preserved in the modernized system, while development, test, and production environments were migrated to AWS providing flexibility at reduced cost.

The DoD’s projected cost savings is $25 million per year, and they are now able to use popular Java programmers to maintain and enhance the critical component.

Lessons Learned

This project taught the DoD that automated refactoring projects are a viable approach to modernize major legacy systems, including complex COBOL-based mainframes, to preserve the existing business rules within a cost-effective, open system.

We can highlight specific lessons learned during this project:

  • Code conversions via automated refactoring are a low-risk approach to modernize away from legacy platforms and migrate to the AWS Cloud.
  • Breaking efforts into phases (modernize, migrate, etc.) keeps risk low and ensures mission success.
  • Breaking away from legacy COBOL enable a completely new set of sustainment opportunities, such as labor and tooling.
  • Agile development models enable real-time course corrections and reduce delivery risk.
  • Maximum automation is crucial in order to transform millions of lines of code while preserving functional equivalence, reducing risks, and reducing the project timeline.
  • The Java language target allows choosing from a wide range of cost-efficient reliable compute options. In this case, it allowed the elasticity and scalability to meet the mission-critical DoD system needs.
  • Moving away from legacy proprietary mainframe and COBOL to an open Java platform allows access to a large pool of talented architects and specialists for design and operation.
  • Suppressing proprietary COBOL technologies allows more cost-efficient and reliable application servers and databases

If you want to learn more about this project or any of our other 200 successful major modernization projects, please give us a call at 425-284-2800 or send us an email at This email address is being protected from spambots. You need JavaScript enabled to view it.

Published in Uncategorised

One of the largest Japanese Car Manufactures now uses TSRI’s modernization methods to increase efficiency in their manufacturing systems. With the help of systems integrator Comture Corporation, TSRI was able to successfully transform 120k lines of COBOL to Java, in a three-week time-period, with over 99% automation levels. 

  • Customer & Integrator: Comture Car Manufacturer
  • Source & Target Language: COBOL to Java
  • Lines of Code: 120,000
  • Duration:  1 month
Published in Case Studies List
Friday, 22 February 2019 13:07

Code Modernization: Focus on ADA

Code Modernization: Focus on ADA

Ada was designed and released from 1977 to 1983 as a high-level object-oriented language for use in real time and embedded systems. It is used extensively in systems such as air traffic management systems, banking and financial systems, communication and navigational satellites, medical equipment, and in military applications. Currently, although the Ada language has been updated, it is not as common as it once was. The ratio of Java programmers to Ada programmers is now about 20 to 1.

Published in Blog

United States Air Force SBSS ILS-S COBOL to Java on AWS Modernization

A major component of the system is 54 years old, written in COBOL, and provides retail-level business logic. The component runs on mainframes that have proven to be extremely difficult to change and manage, and the DoD needed to modernize the component to drive down operating costs and move to an open platform, while retaining all functionality....

Published in Blog

The U.S. Air Force uses the Integrated Logistics System – Supply (ILS-S), of which the Standard Base Supply System (SBSS) is a major part, as a mainstay of their supply chain. The SBSS program includes over 1.5 million lines of COBOL, as well as smaller numbers of C and Assembly, all of which are to be transformed into Java. 

  • Customer & Integrator: US Air Force
  • Source & Target Language: COBOL to Java
  • Lines of Code: 1.5 million
  • Duration:  11 months
  • Receive an In-Depth Case Study for this Project:
Published in Case Studies List

When that stalwart of facile enterprise development, Visual Basic 6, was retired by Microsoft, it left companies with a variety of problems. While many were able to immediately upgrade to Visual Basic .NET, Java, C++ and other platforms, cases remain in which VB6 was so embedded in the software infrastructure that it could not be easily changed or extricated. TSRI has been working on code transformation of numerous languages for many years, and now includes VB6 transformation.

Published in Blog
Thursday, 24 August 2017 12:54

Code Modernization: Focus on Powerbuilder

PowerBuilder, with its ever-popular DataWindow IDE feature, and strong client-server orientation, is still an important coding mechanism.  It has fallen out of favor in recent years, however, and its codebase has been neglected and moved to Sybase, then to SAP, and now to Appeon. Due to a few missteps along the way, and a late.NET capability addition, many companies are choosing to discontinue their use of PB and move to newer platforms. 

Published in Blog
Thursday, 20 December 2012 15:48

MUMPS to Java - Hawaii Resource Group

TSRI was a subcontractor in support of HRG’s Military Health Systems Transition Application Support (TAPS) Research Project. The objectives of the research were to identify a subset of the radiology module within the Massachusetts General Hospital Utility Multi-Programming System (MUMPS or M) based Composite Health Care System (CHCS), transform it automatically into Java, demonstrate functional equivalence, and gather metrics to support estimates of effort required to transform larger portions of the CHCS code.

  • Customer: Hawaii Resource Group
  • Source & Target Language: MUMPS to Java
  • Lines of Code: 221,372
  • Duration:  3 months
  • Services: Code Transformation, Automated Refactoring, System Integration & Test Support, Transformation Blueprint®
  • Receive an In-Depth Case Study for this Project:


Published in Case Studies List

Stanley and Assoc. contracted TSRI to modernize the Battle Command Software - Advanced Field Artillery Tactical Data System (AFATDS).   This system is an integrated system that provides the Army, Navy, and Marine Corps automated fire support command, control and communications.  Prior to this modernization, AFATDS was written in legacy Ada-83.  The target code selected for the AFATDS modernization was Java.

  • Customer: Stanley
  • Source & Target Language: Ada to Java  
  • Lines of Code: 5.1 million
  • Duration:  10 months
  • Services: Application Blueprint®, Automated Code Transformation, Transformation Blueprint®, Automated Refactoring, Engineering Support
  • Receive an In-Depth Case Study for this Project:
Published in Case Studies List
Wednesday, 23 April 2008 15:27

Ada to Java - Thales EATMS

The Eurocat Air Traffic Management System (EATMS) is used in 16 European countries and Australia. EATMS became subject to a modernization initiative in 2005. Thales Air Systems selected the The Software Revolution, Inc. (TSRI) to modernize this system written in legacy Ada 83. After transforming this application to both Java and C++ for performance testing, Thales selected Java as the final target language and TSRI completed the modernization.

  • Customer: Thales Air Systems
  • Source & Target Language: Ada to Java
  • Lines of Code: 1,700,000
  • Duration:  5 months
  • Services: Tuned JANUS Studio® to European Coding Standards, Code Transformation, Automated Refactoring, System Integration & Test Support, Transformation Blueprint®
  • Receive an In-Depth Case Study for this Project:
Published in Case Studies List
Page 1 of 2


Stay up to date on Architecture-Driven Modernization: