Minimize Risk and Save Time 

 Drawing on 25 years of success, our proven, automated approach decreases risk and
errors and makes it possible to accomplish in months what would take years otherwise.


We don't just transliterate code. We transform it into a modern, native, object-oriented target language such as C++, C#, Java, or J2EE, running on Linux, Unix, Windows and any other any real-time target architecture.


Our automated code refactoring improves code structure, performance, and maintainability post-conversion.


Monolithic applications and databases are transformed into multi-tiered, modular, and cloud-enabled applications ready for your modern architecture of choice.


Up-front assessment and code documentation pave the way for smooth modernization.


Generate full UML documentation for both the "As-Is" (Source Application) as well as the "To-Be" (Transformed Modern Application) systems.

Your Modernization Project & Phases at a Glance!


Phase 0: The Pre-Project Phase

This phases is where you currently are! It does not matter if you are just in the discovery phase of a potential modernization or you have already identified that automated modernization is the way to go for you and your organization - we are happy help you at any point of your modernization journey.

We can guide you through a End-to-End modernization and share our experience on what to look out for, where little or minimal risks are, what the limitations of various modernization approaches/tools/alternatives are and help plan your modernization for you!

Please don't hesitate to call us or message us here if you have any questions!

A truly successful modernization follows the motto: "Measure twice, cut once" meaning that the planning phase is the most important phase within a modernization to uncover unknowns, identify and remediate risks and learn where most of the effort will be.

Phase 1: Application & Modernization Assessment

An application assessment both initiates a TSRI application modernization project, as well as completes the project for customers looking for detailed, cost-effective application documentation.

For customers wishing to retain their existing systems written in COBOL, PL/1, PowerBuilder, MUMPS, Ada, or any of more than 35+ languages, TSRI's code-level documentation enables your existing developers the ability to quickly and easily understand, maintain, and develop the application.

Many of TSRI's customers find that this documentation pays for itself within weeks or a few months and can be utilized while the modernization is being planned and executed, helping the team understand the applications, saving O&M costs, as well as identify areas for further refactoring.

During this phase, TSRI will set up JANUS Studio® to ingest and parse the source code. Once the code is parsed, we can then analyze the legacy system by transforming it into a model, according to standards set forth by the Object Management Group (OMG). This standard, a legacy Abstract Syntax Tree (AST), is an international modeling standard which TSRI helped author, and which allows TSRI to produce an Application Blueprint® (legacy "As-Is" documentation) for all source languages. The blueprint, an HTML-based detailed evaluation of the existing system’s UML design and architecture, provides clients with information that greatly reduces time spent maintaining and developing the legacy application (even during a full application modernization project).

For full transformation projects, the next step is an Internal and External Dependency Analysis, to identify internal and external interfaces and identify missing definitions. Then, we undertake a first-pass, Developer-Ready or “Baseline” Transformation and from that initial code transformation, the Baseline Transformation Blueprint® is generated to identify gaps in the transformation rule sets for generating the source languages. The Application Blueprint® and Baseline Transformation Blueprint® allow inspection of the baseline modernization and provide analytics and metrics for building a detailed understanding of the design and architecture of the target system. This is necessary to support planning of the Target Architecture Design, which will guide subsequent steps in the refinement of the modernization process.

1. Setup
Modification of the TSRI JANUS Studio® solution to be able to ingest and parse the customer’s source code and the generation of the baseline model of the application in the Intermediate Object Model (IOM). This IOM is augmented with semantic analyses including Control Flow, Data Flow, State Model, Cause–Effect and Class Models, Code Complexity Metrics, and Code Redundancy Clusters. The conclusion of this effort is the generation of an inventory report and verification that all code, databases & UI have been successfully ingested & modeled.

Phase 2: Automated Code Transformation

During the Transformation Phase of an application modernization project, TSRI transforms the legacy application code from the Intermediate Object Model (IOM) into object-oriented, native, uniform, platform-specific target code of the client's choice. This transformation also couples the generated code to the target database. This model-based transformation is accomplished at 100% automation levels, which offers clients value unique to TSRI's process.

During this code modernization step,TSRIalso uses the information generated from theTarget Architecture Design plan to produce code ready to be re-integrated with the application's external and internal interfaces, which were identified in the Assessment Phase. Resolution of these external interfaces involves writing code that replaces the functionality of the original legacy services with modernized application logic and replacement services on the target platform middleware (e.g. .NET ADO JSP or ASP framework services). The implementation of the replacement APIs is undertaken by the client, or by TSRI as an Engineering Support Task, whichever is referenced in the Statement of Work (SOW).
1. Deployment-Ready Compilation
Assures that the functionally equivalent modernized code cleanly compiles and links in the target language with the target side framework classes and with APIs whose implementations interface with target side framework classes.

Phase 3: Refactoring & Round Tripping

Once your application is fully ingested into TSRI’s Intermediate Object Model (IOM), our fully automated code transformation & refactoring solution allows for conducting a wide variety of refactoring types. These refactorings re-engineer the application to improve the modernized system’s design, architecture, and maintainability, as well asenhance its performance - all without changing the functional equivalency of the application. TSRI's fully automated approach provides a significant advantage over manual performance enhancements, which can easily corrupt the functional equivalency of a modernized application with human-induced errors.

All refactoring operations are carried out against the IOM to generate redesigned code modules and re-architected application tiers, as part of a standard application modernization project. Unified Modeling Language (UML) is generated and quality metrics are reflectedcontinuously within the Transformation Blueprint®. This captures the design and architecture of the application as it evolves and the series of refactoring operations are applied. The code is regression tested after application of each refactoring operation to verify that the refactoring operation has been applied without loss or distortion of functionality

1. Fully Automated Refactoring
This includes the fully automated identification + removal of dead and redundant code by JANUS Studio®, to improve system maintainability without changing the client'sfunctionality. This type of refactoring does not require customer intervention, and is offered on a fixed price per line of code basis.

Phase 4: Final Iteration

Finally, we are almost done modernizing, testing & integration your applications - but wait, there is more great news!

In the Final Iteration, TSRI takes the the latest and greatest baseline of the source/legacy code currently in production (and being actively maintained and updated), and identifes the deltas between the original code baseline taken at the start of the project.

The new baseline goes through the final iteration - transforming, refactoring, and regression testing the latest and greatest code, and then the modernized system UML is generated and a final Transformation Blueprint® is delivered to the client.

The great news here are, that this means minimal code freeze and business disruption to our clients. We do not ask you to freeze your code and encourage continued development & maintenance of your current application, while we modernize it to a modern functional equivalent application.

According to our clients, this is one of the biggest advantages within our process and modernization journey.

During the final release iteration(s), TSRI supports transitioning the system into production. For complex systems or portfolio modernizations, this may require several iterations, automated test suites or more exhaustive testing and additional refactoring to achieve final Client acceptance.

1. Final Testing
During this phase, TSRI will support final testing of the system, including pilot/beta testing of the modernized system with a subset of the eventual end users.

Take advantage of our proven process, perfected over more than two decades!

Message us to learn more about your process and methodology.

We are excited to talk to you & explore how we can best help modernize your applications!
Please fill the required field!
Please fill the required field!
Please fill the required field!