Technology & Solution

Since the late 1980s, we have seen many solutions hit the market. Below is an overview all the options we typically see. Generally, there are 5 Modernization/Migration Options:

1. Fully Automated Modernization
   • This option fits well for large, single or multi-language applications that are actively maintained, valueable and irreplacable. TSRI's solution uses model-driven, AI-based, fully automated methods to achieve 100% automation in the modernization of a source application to a target language and architecture of your choice.  Learn more about the advantages of the fully automated approach here.
2. Semi-Automated Modernization
   • Semi-Automated Modernization technologies can work if the source application is small or very small and you have a specific reason to choose a less automated method. However, because of the manual input required to fill gaps in the transformation, the transformation risk with semi-automated modernization increases corresponding to the size of the application, because humans are in the loop touching the code and introducing errors. For example, transliterators (which translate code "line by line") produce legacy-like target code that must be manually edited. Other semi-automated model-driven approaches require additional manual rewriting, often for large amounts of code at large expense and risk. This increases the chances of schedule overrun and increasing costs, and does not allow for automated refactoring, or flexible approaches that allow for mid-project changes.
   • As a result, semi-automated solutions that can handle one or two languages are typically not good solutions for larger projects. Even an automation level of 95% on a 1 million line application means 50,000 lines of code or more must be manually written at dramatic expense.  
3. Application Rehosting and Replatforming
   • Rehosting is a good solution if the application is not actively maintained and only needs to move from its current hardware/platform. This solution retains the legacy language, and so development/maintenance continues to be difficult and costly, and exposes the customer to increased technical debt as fewer and fewer resources are available. Also, the significant license costs associated with rehosting can be unattractive for customers.  In fact, the effort to undertake a TSRI modernization is often equal or lower than 1-2 years worth of licensing cost.
4. Custom Off-the-Shelf (COTS) Solutions
   • COTS replacements are very common for replacing general applications that do not have many custom features. Usually the COTS applications look completely different, have different functionality and have license costs associated with them. This requires costly and lengthy retraining of the current users who are not familiar with the new system and rely on the vendor to "make them work" for the business scenarios. Again, license costs and vendorlock are other disadvantages, as is the ability to maintain and modify the application moving forward.
5. Manually Rewriting Applications
   • Definately the most costly, highest risk and longest approach is rewriting the code manually. This is an approach often used on applications that need massive forward development and required major changes in functionality. The Standish Group, an independent research firm, clearly shows that the high liklihood of "challenged" or "failed" projects, based on hundreds of modernizations/migrations/replacements, should be a major consideration for any manual redevelopment effort. Most of TSRI's successful large modernizations follow a failed manual effort that expended millions or tens of millions of dollars before being scrapped. Request a copy of the Standish Group report here.

TSRI’s JANUS Studio® generates richly indexed and hyper-linked system-level design documentation of the entire legacy system. This is called “As-Is” documentation of the source system, also called Application Blueprint®. Once the system is in its modernized state, the target code is also documented. This is called “To-Be” documentation, also called a Transformation Blueprint® . The “As-Is” and “To-Be” documentations can be combined to allow a side-by-side view of both systems. Customers may receive a free Transformation Blueprint ® using a sample of their own code and choice of target language.

Because our toolset is tuned to the source code to perform near-100% automated code transformations very rapidly, we can make changes to the transformation specifications and then re-transform the entire application after that change is made. While bringing a great deal of flexibility to the project, this allows also us to perform refactorings like eliminating dead and redundant code, code consolidation, architectural level refactorings, or simply make changes to improve maintainability and readability,  then re-transform the code very quickly.

TSRI’s JANUS Studio^® is a suite of integrated tools from which TSRI provides fully automated modernization processes. Specifically JANUS Studio^® will:
1. Perform detailed analyses of legacy source code.
2. Transform legacy source code into modern target languages.
3. Perform initial detailed analysis of target code (to support testing).
4. Apply fully automated refactoring operations.
5. Iteratively apply semi-automated refactoring operations.
6. Perform final detailed analysis of target code (to support testing and future system maintenance)

Yes, TSRI can modernize the GUI and database. We have modernized many different databases such as flat-file, hierarchical, and relational databases. Most of our target databases are relational, such as Microsoft SQL Server, Oracle SQL Server, but we also modernize non-SQL databases and open-source databases.

In regards to online and batch, we do modernize batch and online code. Almost all of the modernization projects included a GUI, online, database, and batch code.

Typically the client or system integrator will be responsible for the following tasks:

• Customer identification and relations
• Executive program management
• Joint proposal preparation
• Requirements definition
• Providing input on generated code for refactoring
• System testing and implementation
• Stub implementation for external interfaces
• Future system enhancements and forward development
• System lifecycle support
• Training of end users

TSRI works in support of the client and system integrator for the entire project.