Displaying items by tag: Refactoring

The U.S. Air Force's Integrated Logistics System - Supply (ILS-S), has been a cornerstone of military logistics for over five decades. This complex and mission-critical system, which tracks more than 35 million assets valued at $18 billion across 1.7 million warehouse locations, has been a significant part of the Air Force's operations, supporting 18,000 users and over 100,000 consumers of ILS-S information across 250 military installations.

Historically, the Air Force had attempted to modernize and move away from expensive Unisys Mainframes without success. Their earlier endeavors earned the system the nickname "The Beast" and was featured in a 2003 book on legacy system modernization by the Software Engineering Institute at Carnegie Mellon.

However, the outcomes changed dramatically when TSRI, NTT Data, and CGI leveraged TSRI’s model- and rule-based transformation and refactoring solution, JANUS® Studio, to modernize the 1.3 million lines of COBOL to Java and migrate the system to an elastic, secure, cloud-native environment on AWS GovCloud.

Watch Paul Saladna, Lead Architect at NTT Data discuss what made this project so successful!

In the initial phase, TSRI converted the 1.3 million lines of Unisys COBOL to modern, maintainable Java and the teams migrated the system to an on-prem mid-tier environment. In a second phase, the application underwent further automated refactoring by the teams for code quality and performance and then migrated to the AWS GovCloud, gaining the benefits of a cloud-native, scalable multi-tier environment like setting up DevSecOps and CI/CD pipelines and providing network interoperability. 

This transformative project marked a significant milestone in automated modernization and cloud-native deployment for the Air Force and has been heralded as a huge success by the USAF, setting a precedent for future modernizations.

“All told, we started at $30 million prior to the modernization and ended at about $3 million post-modernization; a pretty significant cost savings!”

Paul, who started with ILS-S back in 2003, played a pivotal role in transitioning the system from a fragmented, green-screen-based setup to a unified cloud-computing solution. His leadership was instrumental in steering the project from its inception, through its on-prem modernization phase, to its ultimate migration to a cloud-native architecture on AWS.

The modernization's driving forces were multifaceted, focusing on reducing infrastructure costs, mitigating COBOL developer dependency, and enhancing platform stability and capabilities. The Air Force required a fast and seamless transition with no loss in functionality or performance, despite the concurrent challenges posed by active military engagements.

The decision to adopt AWS GovCloud was influenced by the Air Force's existing computational frameworks and the natural fit of AWS for Java/Python-based projects, given its extensive use and the associated economies of scale.

TSRI was chosen for this monumental task through a rigorous selection process, showcasing unparalleled automation capabilities and a thorough understanding of the legacy COBOL code, which set them apart from other vendors.

“TSRI demonstrated the highest degree of conversion capabilities and past performance and represented the lowest risk for us to achieve mission objectives. Really, they stood out.”

The outcomes of this modernization are profound, achieving a 90% reduction in total costs—from $30 million annually to approximately $3 million post-modernization. Additionally, the project facilitated the reassignment of COBOL developers to roles where their deep understanding of the system's logic and business requirements could be leveraged for the modernized ILS-S system.

The modernized ILS-S now boasts a remarkable 99.999% uptime, a testament to the enhanced platform stability and capabilities achieved through this project. This success has prompted the Business and Enterprise Systems Directorate (BES) of the USAF to replicate this modernization model across other critical systems, with TSRI currently working on the modernization of the Air Force's wholesale Stock Control System.

This journey from COBOL to Java, culminating in a truly cloud-native deployment on AWS, not only signifies a technological leap for the Air Force but also exemplifies a model of collaboration, innovation, and strategic foresight in modernizing critical defense systems.

To learn more about the project, read the case study

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! 

Additional Sources:

• https://federalnewsnetwork.com/it-modernization/2022/11/lessons-learned-from-air-forces-ils-s-logistics-system-modernization/
• https://www.aflcmc.af.mil/News/Article-Display/Article/2888877/system-tracks-every-item-in-the-air-force-inventory/

TSRI adapted its industry-leading modernization capabilities to the unique Pitney Bowes Visual Basic 6 (VB6) code constructs for a successful automatic modernization of over 443,000 lines of VB6 code and over 450,000 lines of XML meta-data to modern C# .NET Core coming in well within budget and completing the transformation earlier than scheduled.

Additionally, TSRI’s partner, Accenture, had the opportunity to manually rewrite the user interfaces for the application, to achieve a modern and user-friendly experience, while TSRI simultaneously completed the automated transformation of the application code and database written in VB6. As a result, the application achieved total functional equivalence while the look and feel of the front end was greatly improved.

Customer: Pitney Bowes Source & Target Language: VB6 to C# .NET Core Lines of Code: 893,000 Duration: 5 Months Services:  Iterative Code Transformation, Defined VB6/.COM and C#/.NET Core component mappings, Automated Refactoring, Transformation Blueprint®

Educational Testing Service (ETS) is the world's largest private educational testing and measurement organization. Each year, they develop, administer,  and score more than 50 million tests, including the TOEFL®, TOEIC®, GRE®, and Praxis® tests, in more than 180 countries. This requires an enormous data management capability. ETS turned to TSRI to transform their ECT and Praxis applications and databases from IBM job control language (JCL) and COBOL Batch to modern Java SE 17 in a cloud-native optimized AWS environment. To do this, they used a spring boot-type application to implement web services invoked by Python. TSRI also converted the IBM DB2 database and VSAM sequential database files to a relational PostgreSQL database on AWS Aurora.

Customer: Educational Testing Service (ETS) Source & Target Language: IBM COBOL to Java SE 17 on AWS Lines of Code: 1,199,633 lines of COBOL and JCL Duration:  11 Months Services: Automated Code Transformation, Automated Refactoring, Integration and Testing Support, SonarQube Quality Refactoring, Code-Specific Adaptation, Database Migration, Transformation "To-Be" Blueprint®, Application "As-Is" Blueprint®, Code Warranty

CRA and AWS engaged with TSRI to complete the modernization of their COBOL-based system to Java on AWS. To Achieve CRA's goals, TSRI tuned JANUS Studio® to parse, transform, document, and refactor the IBM z/OS COBOL application. In just 1.5 months, TSRI modernized the application from an IBM Mainframe COBOL and CICS monolith to a modern multi-tier architecture in Java on the AWS cloud. Just as important, TSRI also converted the DB2 database and VSAM sequential files to a relational PostgreSQL database on AWS Aurora.

Customer: Canada Revenue Agency (CRA) and AWS Source & Target Language: IBM COBOL to Java on AWS Lines of Code: 168,000 Duration:  1.5 Months Services: Automated Code Transformation, Automated Refactoring, Integration and Testing Support, SonarQube Quality Refactoring, Code-Specific Adaptation, Database Migration, Transformation "To-Be" Blueprint®, Application "As-Is" Blueprint®

The Pitney Bowes Postage Payment Application had been running COBOL for decades on an HP NonStop Tandem mainframe, however, to seize the opportunities of the digital cloud age and to reduce overall technical debt, Pitney Bowes needed to modernize the Tandem COBOL to C# .NET Core. Just as important as the code, the HP NonStop Tandem database needed to also be migrated to a modern Microsoft SQL Server database and deployed to AWS. TSRI successfully transformed the application at 99.96% automation, and deployed the modernized application on the AWS cloud.

Customer: Pitney Bowes Inc. Source & Target Language: COBOL to C# .Net Core on AWS Lines of Code: 390,000 Duration: 6 Months   Services:  Automated Code Transformation (99.96% level of automation), Automated Refactoring, Database Conversion: File based system to a Microsoft SQL Environment, Integration and Testing Support, Transformation Blueprint®, Application "As-Is" Blueprint®,

How long would it take you to complete 25,000 tasks that take thirty minutes each?

Before you drag out your calculator, that’s 12,500 hours, or about 1,562 working days. Wouldn’t it be better to have it all done in under an hour? That gives you an idea of how refactoring—when done correctly—can accelerate modernization process and deliver accuracy in the range of just one error among 20,000 lines of code. That’s the kind of accuracy that’s needed for critical systems. Let’s talk about how refactoring achieves it so fast.

The refactoring phase of modernization at TSRI takes a project beyond updating the code and database to modern standards and system architecture. Sure, the planning, assessment, transformation, and integration phases of a modernization process get the mass of the work done. But more is needed. Imagine if a great painter only took a portrait to the point of getting the features in the right places. For functional equivalency, high performance, and future-readiness you need to dive into the details to get them as right as the original—and ready for future enhancements and needs.

That’s where refactoring can be hugely beneficial. If, after the transformation and integration phases you have to find and address each issue manually over hundreds of thousands or millions of lines of code, you may as well add those 12,500 or more hours back in. That’s why refactoring is key. By including an iterative code scanning and refactoring phase to the modernization process, TSRI automatically and semi-automatically remedies a host of issues at scale that would make developers run for the hills, including:

• Pinpointing and getting rid of dead or non-functional code
• Merging and consolidating duplicate code and data
• Improving design of code and data
• Eliminating system flaws from transformed software
   

"TSRI's refactoring process creates reusable components that can be applied to future projects"

And beyond those cleaning and refining functions, a well-designed refactoring process also provides forward-looking advantages. TSRI’s refactoring process improves maintainability, remediates security vulnerabilities, increases performance, and modularizes functionality. It also creates reusable components that can be applied to future projects for optimization, packaging, and redistribution.

When you’re able to reuse some or all of the outputs of automated or semi-automated refactoring, you don’t have to recreate the mechanisms for modern microservices, REST calls, and other reusable elements. They’re at your fingertips and ready for integration in modern environments or databases for future projects. It gives you the best of modularity, but customized and created specifically for your systems’ needs such as data-dictionaries, code and record consolidation, introduction of logging or comments, and more.

"It gives you the best of modularity, but customized and created specifically for your systems' needs."

One scan, one rule, and thousands of fixes

A key part of the refactoring process is scanning the newly modernized code to find issues for remediation. To do this, we use the SonarQube scanning tool. SonarQube is an open-source platform that executes continuous inspection of code quality in modernized code. It provides a detailed report of bugs, code smells, vulnerabilities, code duplications, and more. Once SonarQube has identified problems in the code the TSRI team can use the results to resolve the issues and improve code maintainability issues and security vulnerabilities.

This is where the economy of rules comes in. Once SonarQube has pointed out issues across thousands of lines of code, TSRI uses that intel to identify the types of issues that need to be addressed. When an issue appears once in an application, it often appears hundreds or thousands of times, and a single rule applied across all code can eliminate a host of individual instances.

So how did we get to those 12,500 hours we started with? We didn’t just make it up. In a TSRI project for Deutsche Bank, a single rule created based on a scan of the code fixed about 25,000 instances that issue. SonarQube estimated it would take 30 minutes to fix each instance. That means refactoring automated the remediation process and saved them about 12,500 hours of software development time. That’s a lot of Marks.

The proof is in the work. Refactoring can not only save thousands of coder hours, but a combination of code scanning and refactoring can also uplevel your modernization with:

• Maintainability making it easier to update and manage code going forward
• Readability for modern developers to find and improve the functions they need more easily
• Security by increasing the speed with which security issues can be found and remediated either manually or through refactoring rules
• Performance greatly increasing the efficiency of the application—for instance, enabling multiple services to run in parallel rather than sequentially.

Find out what refactoring done right can do for you, contact TSRI now

----

Proven by decades of results. Prove it for yourself.
For decades, TSRI clients have been discovering a dramatically faster, more accurate, and less expensive AI-based and automated modernization process. We’ve earned a place as the go-to resource for enterprise corporations, government, military, healthcare, and more. Now prove it for yourself. Find out how the proprietary TSRI modernization process delivers future-ready, cloud-based code in any modern language in a fraction of the time.

See Case Studies 
Learn About Our Technology 
Get Started on Your Modernization Journey Today! 

Shaw Cable Systems, one of TSRI's Candian customers, engaged TSRI to modernize their CBS system, which involved 772,684 lines of VMS VAX BASIC source code and 275,707 of VAX Basic comments.  The system modernization called for code conversion to C#, along with other services. 

Customer: Shaw Cable System Source & Target Language: VMS VAX BASIC to C# Lines of Code: 1.1 Million Duration:  5 months Services: Automated Code Transformation, Automated Refactoring, Separation of the business and data logic into tiers, Integration and Testing Support,  Engineering Support, Transformation Blueprint®

The Oregon's Public Employees Retirement System (OPERS) serves approximately 300,000 employee members, inactive members and retirees from more than 850 public employers. OPERS required a major maintenance action of the OPERS Benefit Estimation Subsystem (BESS) and Benefit Calculation Subsystem (BCSS) to address changes in Oregon State retirement regulations. TSRI's automated refactoring capability was used to consolidate the applications and remove dead and redundant code.

Customer: State of Oregon Public Employees Retirement System     Source & Target Language: COBOL Refactoring Lines of Code: 250,000 Duration: 4 Months   Services:  JANUS Studio® Automated Refactoring, Testing and Implementation Support, Application Blueprint®

Sempra Energy needed to move their Microgrid Control System (MCS) application into a more contemporary environment. The challenge that TSRI and mLogica faced was transforming Sempra Energy's existing Sybase OpenServer platform into a more modern .NET/MS-SQL server environment under strict budget and schedule constraints. The project, which included the modernization, documentation, refactoring, testing, and integration of the application, was successfully concluded on-time and within budget constraints.

Customer: Sempra Energy & mLogica Source & Target Language: C to MS-SQL/C Lines of Code: 211,000 Duration: 4 Months Services: Automated Code Transformation, Automated Refactoring, Round-tripping, Unit Testing, Third Party Code Quality Refactoring, Integration and Testing Support, Transformation Blueprint®, Application Blueprint®