Question & Answers

All Items
faq
I am skeptical, considering I have heard of so many legacy code modernization failures. Why do they fail and why is TSRI's approach different?

There are a few main reasons why legacy code modernizations fail.

First, manual re-writes can take a great deal of time, particularly for large applications. During this time, changes to the project goals may cause further delays or even cause the project to restart from the beginning. The cost for manual rewriting of code is already very high, and so starting over becomes particularly costly.

Also, long code freezes of months and years are common with manual or semi-automated conversions, which result in major issues for your user base, and eventually project failures.

Transliterative tools that focus on line-by-line translations of the source code into the modern code are also widely used. Just as using a dictionary to translate from another language to English one word or sentence at a time would result in many areas of confusion, so these tools produce results that don’t accurately reproduce the functionality of the original application.  Even when completed, this results in complicated and unmaintainable applications.

Finally, the costs associated with large numbers of people on partially-automated and manual modernization projects can be very high. These costs grow as features are added or changed several months or years into the project, until millions and often hundreds of millions have been invested.

The fully 100% automated functionality of TSRI’s JANUS Studio solves all of these problems, and is the reason why all of our past projects were successfully completed, and all of our past projects are reference able. This perfect track record of success has been honored by awards ranging from the Stevens award for our CEO Philip Newcomb, as well as the Top 20 Most Promising Defense Technology award from CIO Review.

What are the different options for modernization?
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 an 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,000,000 line application, means that 50,000 lines of code or more must be manually written, at dramatic expense.  
  3. Application Rehosting & Replatforming
    • Rehosting is a good solution if the application is not actively maintained and only needs to move off 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 independant research firm, the Standish Group, shows clearly 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.

Learn more about modernization options from independent 3rd party research:

Standish Group Podcast on Modernization Options:

What System-Level Documentation are offered by TSRI?
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.
What are the advantages to TSRI's approach?
Because our toolset is tuned to the source code to perform 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- and then re-transform the code very quickly.
What are TSRI's Tools & Processes for Modernization?
TSRI’s JANUS Studio® is a suite of integrated tools from which TSRI provides fully automated modernization processes. Specifically JANUSStudio® 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 re-factoring operations.
  5. Iteratively apply semi-automated re-factoring operations.
  6. Perform final detailed analysis of target code, (to support testing and future system maintenance)
Does TSRI modernize the GUI, database, batch, online and other internal calls?
Yes, TSRI can modernize the GUI and Database. We have modernized many different databases, such as flatfile Databases, hirarchical databases and relational databases. Most of our target databases are relational databases, such as Microsoft SQL Server, Oracle SQL Server, but also non SQL based databases and OpenSource Databases.

In regards to the Online and Batch, yes, we have and do modernize batch and online code. Almost all of the modernization projects included a GUI, online, database, and batch code.
What tasks are the Clients or System Integrator's responsibilities?
Typically the Client or System Integrator will be responsible for the following Tasks:
  • Customer Identification & Relations
  • Executive Program Management
  • Joint Proposal Preparation
  • Requirements Definition
  • Providing Input on Generated Code for Refactoring
  • System Testing & Implementation
  • Stub Implementation for External Interfaces
  • Future System Enhancements & Forward Development
  • System Life-Cycle Support
  • Training of End Users

TSRI works in support of the Client & System Integrator for the entire project.

How does TSRI's approach minimize risk?

TSRI’s approach has a 100% success rate over all 130+ major modernization projects we have undertaken, all of which are reference-able projects. This is not magic, but the result of a fully-automated code documentation and transformation process as well as a disciplined and free pre-project assessment phase during which TSRI will identify any potential risks to the project.

The JANUS Studio® transformation provides code that is accurate and uniform, eliminating the risk of technical failure. TSRI reduces financial risk by operating on a Firm Fixed Price (FFP) basis for initial tasking and Firm Fixed Rate (FFR) for testing and implementation support. While manual and semi-automated transformations rely on coordination of many—often hundreds—of developers, TSRI’s automated processes typically require only a handful of project management engineers, typically fewer than 10 people, avoiding the risk of key personnel departures. Finally, because a code freeze of only a couple days to a week is required, maintenance and updating can continue on the application all through the assessment and development process, eliminating the risk, business disruption, and project failure associated with long code freeze periods.

How fast is TSRI's code conversion?
Our tool transforms 1 million lines of legacy code into modern code, in about 30 minutes. This is not magic, but the result of using a 100% automated, iterative code conversion process that has been developed over 2 decades, and hundreds of millions of lines of code. Test-ready code will be produced through this iterative process, which will then need to be tested, integrated, and fielded.
Can you prove that TSRI's technology can transform or document my code automatically?
Yes, definately. If you can provide TSRI with a portion or all of your source code (under NDA if neccessary), we can generate a first-cut Transformation Blueprint® of your source code, which will be available to you as a free preview. This allows you to review your source code and the transformed code, side-by-side. The Blueprint also shows other artifacts, such as structure of the code with Structure Charts, Control Flow Graphs, Data Flow Diagrams, State Machine Models, McKabes' Complexity Index, Similar Code and much more.
What industries does TSRI have experience in application transformation & documentation?
Although we have experience transforming code from a variety of industries, from government, defense, financial, insurance, entertainment, logistics, commercial, our toolset is truly industry neutral. The specific functionality of the application, as well as its external interfaces, databases, user interfaces and other factors do not affect our ability to transform the application to a functional equivalent in a new language and architecture. TSRI has modernized everything from Submarine Weapons code, Satellite Code to Billing Applications for major telecommunication's companies. Our language and industry neutral approach will be applicable to your source application.
No but seriously, when you say 100% levels of code automation, how much additional manual intervention is required?
There is no manual intervention required to transform code via our JANUS Studio toolset; it is 100% automated. As one of the first steps during our modernization, TSRI needs to create a full and complete model of the application. This model is where all the work that TSRI does, for example refactoring and redesigning happens. 
What level of automation is TSRI able to achieve?
TSRI is able to achieve a 100% level of code automation in our artificial intelligence-based transformation engine called JANUS Studio®.

Didn’t find the answer? Contact Us

                                                                                                               

Stay up to date on Architecture-Driven Modernization: