Legacy Software Transformation

The Software Revolution, Inc (TSRI), a Washington State-based business, provides automated legacy computer system modernization services for government and industry customers. TSRI automatically modernizes legacy systems into modern, platform-independent object-oriented languages following the OMG Architecture Driven Modernization approach. Language-neutral re-factoring transforms a platform independent intermediate model to improve design, performance and maintainability before platform specific code is generated. Unified Modeling Language (UML) documentation is generated to fully document the legacy system as well as the modernized system which is generated into platform specific C++, J2EE/Java, or C#. Please click on the legacy modernization case studies on the right or visit The Software Revolution website for more information.

TSRI's approach to legacy system modernization permits gradual integrated steps within a model-driven methodology. Each step adds to a repository of knowledge about the application portfolio and guides subsequent steps in the modernization process. TSRI's automated processes insure consistent code integrity so manual intervention is seldom if ever used. Human decision-making is introduced only when necessary to guide the automated processes.

TSRI legacy system modernization begins by applying transformation rules to generate a platform independent model from the legacy application source code. TSRI calls this the Intermediate Object Model (IOM™). Platform specific rules are then applied to the IOM™ to derive the modernized application's source code. Any changes to the Model Driven mModernization (MDM) process are accomplished by modifying rules or models. The software tool set developed by TSRI containing these models, rules, and automated processes is called JANUS™.

UML documentation can be generated to support multiple views of all modernization products. Code models and UML design can be interchanged using XML Metadata Interchange (XMI) with other vendors' tools. JANUS™ traces all rules to every object model touched or created during the transformation process. TSRI solves the O(N-squared) language transformation combinatorial problem by transforming all legacy source languages into the IOM™, a common platform and language neutral model. From the IOM™ multiple modern object oriented target languages can be generated for platform specific targets. The IOM™ consists of a set of language constructs common to all languages. By using the IOM™ as an intermediate model, the inherently O(N-squared) language transformation problem is reduced to an O(N) problem and model driven processes for assessment, analysis, metrics, documentation and re-factoring are reduced to O(1) problems. These are consistently and uniformly solved for all languages and platforms within the IOM™.

As an Object Management Group (OMG) Platform Member, TSRI is a leading contributor to the Architecture Driven Modernization Task Force (ADM TF) where TSRI seeks to advance OMG standards supporting best practices. TSRI's JANUS™ technology tools and services adhere to the OMG ADM TF standards and recommended practices.

A History of Automated Software Re-Engineering

The following is a short history of automated automated software re-engineering and modernization projects, dating from 1989 through 1999. Before founding The Software Revolution in 1995, Mr. Philip Newcomb conducted 25 industrial research projects at Boeing Research and Technology that demonstrated the industrial value of automated software reverse-engineering, re-engineering, reuse, program understanding, testing, verification and validation on many major Boeing programs. As a subcontractor to Boeing Information System (BIS), Mr. Newcomb demonstrated the applicability of automated function and structural testing on the Mechanization of Contract Administration System (MOCAS) for the Defense Information System Agency (DISA), under the Defense Enterprise Information Services (DEIS I) contract. From 1995 through 1999 Mr. Newcomb developed and applied Revolution 2000™ to Y2K Independent Verification & Validation (IV&V) projects for over 30 major Fortune 500 customers. Starting in 2000, The Software Revolution, Inc built upon Revolution 2000™ creating eVolution 2000™, a technology that used knowledge-based technology for automated software modernization. In 1999 TSRI commenced development JANUS™, a pure MDM technology for automated modernization of legacy software systems. JANUS™ is the 4th in a series of automated software technologies developed by TSRI's founder since 1978. TSRI has used JANUS™ on over 30 major automated software modernization projects for the eight leading government Information Technology (IT) vendors.

Knowledge Integration Tool, 1985-1988: The Knowledge Integration Tool (KIT) a Knowledge Based Software Engineering (KBSE) environment was written in LISP and Carnegie Representation Language (CRL). KIT was an early generation reverse-engineering environment for Artificial Intelligence (AI) software written in Prolog, OPS and CRL. KIT was a facet of Crystal, a project between the Boeing AI Laboratory and the Carnegie Group to use AI for improving software engineering processes and practices.

Prototype Reverse Engineering Workbenches, 1989: Prototype reverse engineering workbenches for JCL, COBOL, Fortran and Ada, were written in Refine™, Dialect™ and Intervista™ from Reasoning Systems. These workbenches demonstrated the feasibility and value of model-based software modeling techniques in the USAF Knowledge Based Software Assistant (KBSA) program by improving software practices for conventional 3GL languages, including JCL, COBOL, Fortran and Ada. This program commenced a multi-year Boeing program that pioneered model-based software transformation technology on over 25 industrial projects within Boeing.

Generic Language Translator (GLT) 1989: The GLT was an early effort to incrementally derive generic pattern-based language transformation rules based on patterns in the syntactical structure of language constructs. This early attempt to use syntactical patterns as the basis for language transformation never achieved closure nor completeness and was eventually abandoned.

COS JCL to UNICOS Translator, 1989: The COS JCL to UNICOS Translator demonstrated the value of automated transformation technology by translating a job control language to a scripting language. It developed grammars and domain models for COS JCL and UNICOS C Shell, and rules for transforming COS JCL into UNICOS CSH. COS JCL is the Cray Operating System Job Control Language. UNICOS CSH is the Unix Operating System C Shell, or the Cray YMP. This language translation approach used transformation rules written directly in Refine™, a 5GL wide spectrum language, applied to the COS JCL language models. Lessons learned from this project and eVolution 2000™ a decade later, lead to the developement of TSRI's domain specific language for model-based language transformation, JTGEN.

Peace Shield Physical Configuration Audit (FRET 1), 1990: The Peace Shield Physical Configuration Audit demonstrated the value of using automation for checking code for conformance to coding standards. It was used to audit 350,000 lines of sub-contractor supplied code from the Peace Shield Program. FRET 1 was a production-level Reverse Engineering Workbench and source code audit tool for detecting coding and naming standards violations, dead code and other anomalies and deviations from coding standards. Specifically it analyzed FORTRAN 77 with imbedded EQUEL, an embedded SQL developed by Ingress.

Fortran Reverse Engineering Tool (FRET 2), 1990: FRET 2 extended the demonstration pilot of the FORTRAN Reverse Engineering Tool, FRET 1, to support inter-procedural control flow analysis, program unit analysis, set-use analysis, distributed processing and analysis merging.

C Loop Parallellization Project, 1990: This project illustrated the analysis of Berstein loop dependency conditions and performed program transformations by introducing forks and joins to replace loops in C programs. It also introduced parallel processing constructs into the C language to automate conversion of C programs from sequential to parallel processing.

Generic Language Workbench (GLW), 1990: The GLW developed a graphical user interface with pull-down menus, window management, window placement, window sizing, and hyper linking between sources and graphs. This work was the Production Prototype of the user interface used in a common commercial language reverse-engineering workbench.

The Source Code Analysis Tool System (SCATS) for C, 1990: Developement of the SCATS prototype produced a C reverse-engineering tool which automated software test support for avionics systems written in the C language. It had the capability for program partitioning and partition intersection analysis.

COBOL Reverse Engineering Workbench, 1991: This enhanced COBOL workbench included full control flow, full data flow (UD|DU analysis), control flow graphs, data flow graphs, structure charts, indented outline browser, postscript (for diagrams, tables and browsers), pretty printer windows, enhanced user interface, formatted document generation, query-based set use, and Semantic Transfer Language (STL).

Payroll Modularization Pilot, 1991: The payroll modularization pilot was applied to COBOL programs as large as 40,000 lines. The programs were decomposed into equivalent modularized programs. Modularization occurred interactively under user guidance or in a batch model. Data clean up and parameterization were performed automatically or under user guidance.

Ada Testing Workbench, 1991-1994: The Ada Testing Workbench project developed a reverse-engineering and testing workbench for Ada. It provided: (1) A Diana-Tree Compatible Ada Language Model with abstract syntax, lexical analyzer, scope analyzer, Ada type checker, Data Cross Reference Reports, and Ada Library Management. (2) An Automatic Software Testing Workbench Prototype with statement coverage testing analysis, decision branch coverage testing analysis, and path coverage testing analysis. (3) Automated Formal Semantics Capture Techniques with derivation of formal specifications from Ada code and mechanical theorem proofs for properties of program paths.

Fortran Workbench/CATIA FORTRAN Documentation, 1991: The FORTRAN Documentation project developed a prototype set of Refine/FORTRAN workbench extensions. These extensions allowed partial reverse-engineering and documentation of Boeing CATIA-related FORTRAN to satisfy Boeing coding standards.

Object-Oriented Model/Hierarchical State Machine Abstraction, 1991: The procedural to Object-Oriented Model (OOM) project developed a COBOL workbench extensions to support the abstraction of object-oriented classes from COBOL. Methods were extracted by a slicing program driven from a state machine model and control flow graphs. Control logic of the OOM was represented in state-transition tables in terms of state variables and methods. Methods associated with the same data variable could be merged. Data-flow models were generated in terms of methods and classes for each paragraph.

COBOL Workbench Robustification Enhancements, 1992: This project enhanced the Boeing COBOL Reverse Engineering Workbench (BREW) bringing the GUI closer to the motif standard. It also tested the parser and grammar on several systems of up to 1 Million LOC.

COBOL Workbench Testing Enhancements, 1992: Further enhancements to the Boeing COBOL Reverse Engineering Workbench (BREW) were devoloped during this project. These enhancements included language neutral control flow graphs and integrated test coverage specifications, (statement, decision, decision/condition and modified condition decision coverage).

COBOL Workbench/Data Centered Modularization, 1992: The Boeing COBOL Reverse Engineering Workbench (BREW) was extended to allow for modularization based upon 01 level record selections and program slices pertinent to 01 level data elements.

Refine Reverse Engineering Development and Documentation Tool (R2D2), 1993: The R2D2 tool was developed to automatically document Refine code. The tool generated structure charts, mini-specifications, and data models for individual functions and subsystems written in the Refine 5GL. R2D2 used an incremental outline browser for Refine knowledge-based objects and referenced functions. The outline browser displayed domain models, syntax, configuration control, problem reporting and problem resolution.

Procedural Methods(QPM) Translator, 1993: This translator was developed to transform Fortran code into a data-flow processing environment called the Quasi-Procedural Method. Fortran commons and parameters were transformed into data-base variables. A data driven dependency network was developed to dynamically determine efficient computation flow and reuse of cached function values.

COBOL Workbench/Redundancy Analysis, 1993: Developed an extension to Boeing COBOL Reverse Engineering Workbench (BREW) to assess the amount of redundancy in COBOL systems by comparison of trait vectors of paragraphs. Paragraphs were clustered based upon correlations between trait vectors.

COBOL Workbench/Trait Analysis, 1993: This project extended techniques for redundancy analysis by the adding composite and deductive traits and trait hierarchies. The project included the development of a light weight C++ trait analysis tool independent from the Boeing COBOL Reverse Engineering Workbench (BREW).

COBOL Workbench/ERMS Reengineering Pilot, 1993: The Boeing COBOL Reverse Engineering Workbench (BREW) was applied to allow the use of SQL in the Boeing Equipment Record Management System (ERMS), an 800,000 line COBOL system. This project developed BREW extensions to standardize data variable names, qualify data usage and introduce the Data Manipulation Interface (DMI) into ERMS.

COBOL Workbench/Usability & Stabilization, 1993: This effort made significant improvements in the usability of the COBOL Reverse Engineering Workbench (BREW) workbench providing a more complete analysis, a more robust interface, and broadened support for multiple dialects.

Cataloguing Facility, 1994: This project provided a facility to catalogue legacy systems into a persistent object base. It also developed a meta-modeling language for annotation and description of legacy system properties in a file system based ASCII description language.

Jovial Workbench, 1994: A prototype Jovial Language Workbench was developed for the J3B2 dialect of Jovial. This workbench supported modeling and analysis of Jovial and translation of Jovial into Ada.

The Marine Corp Reengineering (MCRE) project, 1994: The MCRE project developed and applied program understanding and transformation to support the migration of 1.3 Million lines of Marine Corp programs into the Joint Maritime Command Information System (JMCIS).

The Software Revolution Inc. (TSRI) was founded, May, 1995: Philip Newcomb left Boeing Research and Technology, in May 1995 and founded TSRI. He became a subcontractor to the Boeing Defense Enterprise Integration Services (DEIS I) contract.

Regression Testing Prototype, 1995-1996: The Software Revolution Inc. (TSRI) developed extensions to the commercially available version of the COBOL Reverse Engineering Workbench (BREW). This effort supported the automated regression testing analysis for the Mechanization of Contract Administration System (MOCAS) of the Defense Information System Agency (DISA) under the Defense Enterprise Information Services (DEIS I) contract.

Revolution 2000™, 1996: The Software Revolution Inc. (TSRI) developed a commercial suite of model-based program understanding technologies to support Y2K analysis for the Ada, C, COBOL, Fortran, Open-M, and Jovial languages. Y2K Customers for Revolution 2000™ included Boeing Information Systems (BIS), Bridgeway, Boeing Employee Credit Union (BECU), Idaho National Environmental Energy Laboratory (INEEL), Miter, PETRON, Reasoning Systems, TRW, and Weyerhaeuser.

Case Studies

The National Endowments for the Arts (NEA) attempted a manual modernization of 3 Wang COBOL administrative sub-systems. This manual effort ended in complete failure. NEA engaged TSRI to document, transform, re-factor, and web-enable these sub-systems. With these automated services, NEA attained a sucessful modernization. More COBOL Modernizations

The Naval Network Warfare Command (NETWARCOM) required modernization of a Navy legacy information system written in VAX-Basic. TSRI's automated tool-set transformed the VAX-Basic code into J2EE/Java. TSRI also made several design adaptations to preserve the system's functionality while modernizing its architecture and allow web-enablement. 

TSRI was selected for Northrop Grumman's "2002 Small Business of the Year Award" for services provided in this Tandem COBOL85 and Tandem SQL modernization to C++ and Oracle9i. The automated services provided by TSRI included "As Is" documentaion, transformation to C++, re-factoring, "To Be" documentation, and web-enablement. More COBOL Modernizations

The US Navy required the Ada to C++ modernization of a Multi-band SATCOM Terminal. Raytheon selected TSRI for the automated assessment, transformation and re-factoring of this system. More Ada Modernizations

The US Air Force's WDAC system fuses radar and satellite data to create fine-scale weather products for operational commanders. Raytheon contracted TSRI for a 100% automated transformation of the system's Fortran code into J2SE/Java. Users of the new WDAC will access weather data through secure internet protocols. More Fortran Modernizations

Computer Sciences Corporation (CSC) engaged TSRI to support the modernization of a legacy system consisting of both C and COBOL for the Bureau of Citizenship & Immigration Services. Automated services provided by TSRI included "As Is" documentaion, transformation to C++, re-factoring, and "To Be" documentation.

Premera Blue Cross needed to modernize an automated assembly system. TSRI was contracted to assess the system, transform its legacy Wang COBOL into C++, and re-factor the modern sytem. The legacy system was capable of self-generating COBOL code. After TSRI's efforts, the modern system accurately self-generated equivlent C++ code.

The U.S. Air Force's Weapons System Cost Retrieval System was written in COBOL, ran on an AMD-5890 platform, and used a flat file data base. TSRI was engaged to perform the COBOL to C++ transformation and to separate data manipulation commands from the business logic allowing for an upgrade to a relational database.

The U.S. Air Force's Core Automated Maintenance System consisted of a Unisys DMS 2200 database and over 3.5 million lines of Unisys COBOL code. TSRI generated 120 Gigabytes of high-fidelity UML documentation to facilitate integration with the Integrated Maintenance Depot System.

The Oregon's Public Employees Retirement System required the modification and integration of two subsystems comprising over 250,000 lines of COBOL II code. TSRI's assessment and refactoring services reduced the complexity, eliminated redundancy and removed obsolete functionality to support the consolidation the two subsystems.

The Defense Technical Information Center attempted to manually modernize and web-enable a UNISYS 2200 COBOL application. The time and expense in transforming less than one third of the system into Java prompted the selection of TSRI's automated sloutions to complete the project. The cost savings for DTIC are estimated at over $440,000.

Computer Sciences Corporation (CSC) engaged TSRI to support the modernization of a legacy COBOL system for the Bureau of Citizenship & Immigration Services. Automated services provided by TSRI included "As Is" documentaion, transformation to C++, re-factoring, and "To Be" documentation.

STG, Inc. awarded a contract to TSRI for the transformation, re-factoring and documentation of a Department of Defense administrative system. This modernization involved the automated transformation of HP COBOL into object oriented C++ and re-hosting the system's database.

The U.S. Navy's carrier-based E-2C Aircraft required a display system modernization. Digital Systems Resources (DSR) contracted TSRI to provide automated Ada to C++ transformation of its Mission Computer Fault Isolation Program.

Northrop Grumman engaged TSRI for the Ada to C++ modernization of the Joint Mission Planning System (JMPS). TSRI's automated services included documentation, transformation, and re-factoring of the legacy code.

The US Navy required the Ada to C++ modernization of a Multi-band SATCOM Terminal. Raytheon selected TSRI for the automated assessment, transformation and re-factoring of this system.

The USAF completed a year long manual modernization of a 50,000 line JOVIAL module from the F-16 cockpit. TSRI's automated transformation of the same module attained C++ code of comparable quality to the manually converted code. The Air Force was further impressed when a single TSRI engineer automatically transformed a 2nd similar JOVIAL module into C++ in only 15 minutes.

Lockheed Martin engaged TSRI to demonstrate their automated transformation capabilities for the US Strategic Command. The demonstration involved an 80,000-line Fortran test sample. In the final demonstration it took only 20 minutes to automatically transform the legacy Fortran into a functionally equivalent C++ module.

Litton/PRC required a proof-of-concept demonstration to illustrate the cost effectiveness and feasibility of automated tools in modernizing Fortran and Assembler code into a modern software language. The modernization strategy demonstrated by TSRI received outstanding marks by government evaluators for risk mitigation.

A Space and Naval Warfare Systems Command (SPAWAR) system required a Fortran to C++ modernization. Raytheon, the prime contractor, awarded TSRI a contract as the sole provider of automated assessment, transformation and re-factoring for this Fortran system while meeting stringent SPAWAR quality standards.

A US Air Force radar system required comprehensive documentation to assess its consolidation potential. This system exceeded one million lines of C and Fortran code. TSRI automatically generated documentation for all programs in the system.

Boeing required a new version of a mission-critical avionics software package for its Advanced Light Weight Combat Aircraft. TSRI successfully converted the J73 JOVIAL into C++, delivering Boeing an accurate error free avionics package which compiled and linked cleanly.

In support of the MILSTAR sattelite modernization effort, TRW contracted TSRI to assess and transform 143,000 lines of JOVIAL code. The automatically generated C++ upgrade of MILSTAR's primary control system was launched in 2004 and now provides enhanced communications for the United States Armed Forces.

Computer Sciences Corp. (CSC) won a down select as a subcontractor to Integral Systems, Inc. (ISYS) following a TSRI to demonstration of its automated J73 JOVIAL to C++ assessment and transformation capabilities. CSC then used TSRI's comprehensive JOVIAL documentation to identify the MILSTAR Mission Unique Software, allowing system integration.

Using a module from the Ballistic Missle Early Warning System (BMEWS), TRW and TSRI performed an early demonstration of automated software re-engineering capabilities. The transformation of J3 JOVIAL into C++ established the initial framework for TSRI's automated tools and services, including automated assessment, transformation, re-factoring and web-enablement.