Minimize Risk and Save Time
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.
Up-front assessment and code documentation pave the way for smooth modernization.
Your Modernization Project & Phases at a Glance!
Phase 0: The Pre-Project Phase
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
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.
This very important step in Phase 1 consits of a series of Workshops to define the final target architecture and any planned activities, such as early refactoring or other adaptations to our transformation engine.Definition and development of a detailed plan for implementing the new system’s architecture. This design activity is conducted with the Client's & Partners architects, Subject Matter Experts and analysts. Because our language-neutral process allows for code modernization from any practical combination of source and target languages, the Client enjoys the freedom of deciding upon a modernized target architecture of their choice, provide code standards, code/quality/performance requirements and works with TSRI on how far refactoring can be taken to achieve the best possible end product.
Our experience tells us that there is no silver-bullet perfect throw-it-over-the-wall kind of tool in the modernization space which can get a client to their desired end product.
Feedback & adaptation are a must and something we have been very prood to support with our powerful refactoring capability!
Phase 2: Automated Code Transformation
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).
Typically, our customers do not want TSRI touching their data, sensitive or classified data. here TSRI will produce data loading scripts for the client. Alternatively, TSRI can extract metadata and data from the database, adaptand export this metadata and data into the target data, and then perform roundtrip validations to prove the equivalence to the original data base.
With our Dual Database-Access-Object (DAO) Layer we can target the source/legacy database and the modern database at the same time and allow for a step-wise go-live, test and integration, as well as going live with areas of the database, Users & User-Groups and functionality of the application. This reduces risk dramatically and show success quickly!
TSRI can modernize the User Interface (UI) to a functional equivalent same look-and-feel UI in order to reduce retraining for your users or any disruption. However, we can also modernize to a brand new UI with a RESTful layer and endpoints and in some cases systematically improve the workflow for the UI and its users as well.
Or both! Quite a few customers have asked us to provide a Dual-UI layer, in order to keep screen scrapers or current users on the same look-and-feel, and have their new users onboarded to a brand new more-modern look-and-feel as well.
If you want to see what that could look like, we have powerful demos that we can show you on what we have done in the past!
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
TSRI can also take specifications from the customer for further code performance optimization, naming changes, or other refinements/enhancements to improve design and architecture, and apply these changes in a fully-automated fashion across the application. These changes are made system-wide, without affecting the functionality of the application, using fully automated technology, but require feedback and input from the customer.
For example, these can include architectural-level refactorings, changing calls from printers to PDF engines, moving from a monolithic structure to microservices, breaking apart highly complex methods into simple and maintainable methods, or remediating security vulnerabilities, among other types of refactoring.
Another example, are refactorings based on the output of of 3rd-party tool such as SonarQube, VeraCode, PMD/Checkstyle, Checkmax, LDRA and others for code quality analysis which give TSRI the neccessary information to build custom refactoring or transformation rules to meet and exceed quality standards and grades for the client.
In addition, tools such as Cast or Fortify can be used to expose security vulnerabilities and TSRI can write customer refactoring rules to remediate them automatically across hundreds of millions of lines of code.
This can also be applied to performance as well, where profiler and profiler tools expose hotspots and bottle-necks and refactoring can be applied to remediate such issues throughout the code.
These types of refactorings are specified by the client, and are used to make those improvements in a uniform and traceable manner, still using a fully automated transformation engine - saving a lot of time and effort for our client's developers and improving the TSRI solution with each iteration for future modernizations.
Yes, your project and portfolio of applications will benefit from the thousands of refactoring efforts and rules that we have created over the last decades!
Since TSRI's functional equivalent modernization also faithfully transform your applications, such Engineering Support can be used to do further improvements and even fix latent bugs/issues that existed already in your source application before the modernization - which of course do not exist in your application, correct? :) - either way, we can utilize Engineering Support to fix such latent defects & issues.
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.
Note that documentation is treated like any other requirement. It should be priced, prioritized, and created only if stakeholders are willing to invest in it.
This can also include our final Transformation Blueprint®, which we also call our Bridge Documentation or Knowledge Transfer Documentation. The Transformation Blueprint® is a detailed presentation of the structure and flow of the modernized code that supports future code maintenance, client feedback, exposes areas for early refactoring and any system restructuring and/or enhancement. As defined, the presentation includes Transformed Code and Design Metrics, Navigation Indices, Control Flow Diagrams, Structure Charts, Data Element Tables, State Machine Models, State Transition Tables, Cause Effect Graphs, and hyper-linked source and target code in HTML format hosted on TSRI’s secure Cloud or a cloud of your choice.
Organizations use this documentation to on-board new developers, help with maintenance, and support the knowledge transfer for their resources.
Take advantage of our proven process, perfected over more than two decades!
We are excited to talk to you & explore how we can best help modernize your applications!