Displaying items by tag: Refactoring
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.
TSRI was engaged to modernize US Navy SATCOM Multi-band Terminal (NMT) Modem Control System (MCS) from Ada to C++. To provide SPAWAR with the best modernization approach, Raytheon selected TSRI to transform the existing MCS Ada code into C++ and to re-factor
the C++ toward the desired target architecture. TSRI's fixed-price "integrator ready" deliverable was selected by Raytheon for its low technical risk,
shortened schedule, and low cost.
- Customer & Integrator: US Navy & Raytheon
- Source & Target Language: Ada to C++
- Lines of Code: 190,000
- Duration: 5 months
- Services: Application Blueprint®, Transformation Blueprint®, Engineering Support, Automated Refactoring
"TSRI Generates 4.5 Million Line Transformation Blueprint For Modernization of Major Banking System."
Kirkland, WA. (June 18, 2009) – A large systems integrator has awarded a highly competed contract to The Software Revolution, Inc. (TSRI) to commence modernization of a major financial management system in the banking sector. Under this contract TSRI generated the Transformation Blueprint to document the before and after transformation of 4.500.000 lines of VMS VAX FORTRAN and 200.000 LOC DMS system into Java, and generated the complete UML Design and Architecture for the target ‘To-Be’ systems. Using the Transformation Blueprint as a modernization roadmap, TSRI provided engineering support services to its system integrator to define strategies for custom reengineering specifications and detailed code analyses to support cost estimation and ROI analysis for the overall project.
Greg Tadlock, TSRI’s Vice President, Sales & Marketing said, “The success of TSRI and its system integrator partner during the Definition phase of this modernization project has provided our banking client with an optimal plan for modernizing their core financial systems, a plan that minimizes the cost, schedule and technical risk parameters while delivering the best ROI to the bottom line in the least amount of time. Through the use of the Transformation Blueprints during the planning phase, the client was actually able see how his multi-million line legacy system consisting of multiple languages and databases would be transformed, redesign and reengineered. After yet another success, we trust the IT community recognizes TSRI JANUS Studio® as the superior solution in the modernization industry, a solution that combines automated modeling, translation, refactoring to reengineer major legacy systems with human guidance but no hand-coding into the highest quality modernized information systems.”
For more information about TSRI, visit our web site or contact:
Vice President of Sales
Phone: (425) 284-2770
Fax: (425) 284-2785
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.
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.