Our Factory Approach to Legacy Modernization
The Updraft modernization factory doesn’t convert your code line by line, leaving you with unmaintainable “JOBOL.” Instead, our factory processes your legacy application according to our Analyze, Improve, Migrate framework.
Each step in this process is customized to your modernization goals, allowing the legacy code to be transformed automatically and the resulting code to be deployed in your target environment without any further adjustments. This delivered code will meet your coding standards and be easily maintained going forward.
Analyze
Modernization begins with understanding the application and its legacy source in order to plan your journey. A clear picture of your application’s business enables you to select the most appropriate future-state target. Separation of business logic from low-level technical detail leads to a much more maintainable, fully modernized application. Identification of features in the legacy code allows these to be precisely replaced with more suitable realizations, where needed. Knowing all the dependencies of an application related to external data and processing resources ensures that the modernized system will continue to interact smoothly with its upstream and downstream systems.
Improve
Applying improvements to a system during modernization will make any application better. For example, automatically replacing inefficient algorithms with faster counterparts will improve the performance of the application. Adapting the modernized code to your coding standards will simplify future maintenance. A more maintainable system results when removing redundant or dead code from the original legacy code, clarifying confusing control structures by eliminating GOTO statements, removing artifacts introduced when the legacy code was generated from 4GL applications, or eliminating the obfuscating effects of outdated concepts such as data redefinitions or pointers that don’t map well to modern object-oriented languages.
Migrate
Updraft’s customized modernization factory transforms the legacy code to your chosen target language and your chosen target systems. While preserving the original application functionality, the modernized system is immediately deployable in your desired open or cloud environment.
Use Cases for Updraft Legacy Modernization
COBOL
All program source components are transformed to object-oriented Java. For example, copybooks become reusable packages, abend errors become exceptions, and paragraphs become methods or program classes. COBOL constructs such as pointers or redefinitions, which do not map into modern language concepts, are supported by easily usable libraries.
CICS
Mainframe middleware concepts, such as CICS transactions, are converted to Java. BMS ”green screens” are transformed into HTML5 or Angular web applications that can be deployed “like-for-like,” or modified and branded to a more modern look-and-feel.
JCL
Job control scripts are transformed into JavaScript, Groovy scripts, or Java programs. Common utilities and sorting supplied by the mainframe are mapped onto facilities provided by the modern environment or supported by provided libraries. Third-party utilities can be easily integrated into the transformed scripts.
Other legacy languages
Updraft also provides automation to modernize proprietary or less common languages: For example, Adobe ColdFusion modernization transforms ColdFusion web pages into HTML5 or Angular and CF Scripts into Java.
Deployment
A legacy application modernized by Updraft can be deployed in the chosen target environment immediately, without any further manual adjustments or refactoring. Deployment choices include:
- Linux client-server environments using application servers such as Tomcat, JBoss, or WebSphere.
- Cloud environments such as AWS or Azure. Cloud deployment fully leverages scalability through distribution of microservices decomposed from a legacy monolith, load balancing, cache servers and monitoring, and so on.
Our Capabilities
Examples of our modernization factory’s capabilities are shown below. If there’s something you don’t see, contact us – chances are we can accommodate you.
Analyze
- Code quality and maintainability metrics (size, complexity, Halstead)
- Architecture and data lineage diagrams
- Behavior flow diagram
- Database, file, and other resource dependencies
- Business rules
- Separation of code into architectural layers
Improve
- Elimination of code replication and clones
- Removal of dead or unused code
- Replacement of GOTO statements by well-structured control constructs
- Conformance to coding standards
- Replacement of inefficient algorithms by higher performance counterparts
- Decomposition of monoliths into flexible microservices
Migrate
- Transform COBOL programs to Java classes
- Transform JCL scripts to Groovy scripts
- Transform BMS screens to Angular or HTML5 web interfaces
- Migrate mainframe CICS middleware to JBoss (or other application servers) on Linux
- Migrate monolithic applications to scalable cloud implementations
- Migrate DB2 access to PostgreSQL
- Migrate flat files to a database
Case Study
Legacy Modernization
A large US telecom operator had attempted several times to migrate their billing system from Mainframe COBOL to a Java-based Linux client-server system. Updraft modernized this large COBOL application while preserving its performance, architectural abstractions, and special constraints governing interactions with upstream and downstream systems. The modernized system has been operating flawlessly since its deployment.
Get Started Today
See why our automated legacy software modernization technology succeeds where others fail. Request a personalized assessment of your current systems and take your first step toward digital transformation today.