Legacy Software Data Transformation via Parallel Thread Processing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Replacing legacy software programs written in older programming languages like COBOL with newer languages is a time-consuming and costly process, as it involves manually comparing and updating thousands of lines of code, handling format mismatches, and migrating data from long-running systems, which can be inefficient and costly.
Innovation Solution
Systems and methods for determining software parity between legacy and new software programs by running them in parallel, transforming data formats, and migrating data efficiently, allowing only threads with errors to be stopped while others continue uninterrupted, thus facilitating a timely and cost-effective transition.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If manual comparison and updating of code is performed to replace legacy software, then software replacement can be achieved, but the process becomes time-consuming and costly
Solution Approach 1:
The patent uses automated code translation to create a copy of the legacy COBOL code functionality in modern programming languages. The system automatically translates COBOL code to languages like Java, C#, or Python, preserving the original logic and functionality while eliminating manual code rewriting. This copying approach maintains replacement accuracy while dramatically reducing the time required compared to manual code migration.
Solution Approach 2:
The patent replaces the mechanical process of manual code comparison and updating with an automated computer-based translation system. Instead of programmers manually analyzing and rewriting thousands of lines of COBOL code, the system uses automated translation tools and algorithms to perform the conversion, substituting human manual labor with computational processes that are both faster and more consistent.
2Measurement precision
If all threads are stopped when an error is detected to ensure software parity, then accuracy is maintained, but processing efficiency decreases
Solution Approach 1:
The patent segments the thread processing into independent units that can be evaluated individually. When an error is detected in one thread, only that specific thread is stopped for correction, while other threads continue processing independently. This segmentation allows the system to maintain high accuracy in software parity verification while preserving overall processing efficiency, as errors in one thread do not halt the entire processing system.
Solution Approach 2:
The patent enables continuous processing of multiple threads simultaneously, ensuring that useful computational actions continue uninterrupted in unaffected threads. The system monitors thread outputs for parity with legacy system outputs and maintains continuous processing flow, stopping only the specific threads that exhibit discrepancies. This approach maintains both measurement precision for software parity and productivity through uninterrupted parallel processing.
3Adaptability or versatility
If data format transformation is performed to match new software requirements, then compatibility is achieved, but system complexity increases
Solution Approach 1:
The patent introduces data format transformation layers as intermediary components between the legacy COBOL system and the modern software system. These intermediary layers handle format conversion, data mapping, and protocol adaptation, allowing the new system to accept data in formats compatible with legacy outputs without requiring complex modifications to the core business logic. The intermediaries absorb the transformation complexity, protecting the main systems from direct complexity exposure.
4Reliability
If comprehensive manual comparison of code logic is performed, then software parity can be ensured, but operational costs increase
Solution Approach 1:
The patent enables the translation and verification process to be self-service oriented, where the system automatically performs code translation, executes test cases, compares outputs, and identifies discrepancies without requiring extensive manual programmer intervention. The automated system serves itself by performing verification tasks that would otherwise require human expertise, thereby ensuring software parity while reducing operational costs associated with manual code migration efforts.
Data Source
AI summary
Systems and methods for transforming data for a batch-based legacy software program into data suitable for processing by a streaming-based new software program. In some aspects, the system generates an information stream for multiple threads from batch information received from the legacy software program. The system processes the information stream for the multiple threads using the new software program. If there is a mismatch between outputs of the legacy and new software programs for at least one thread, the system adjusts a data model of the new software program to address the mismatch and generates an updated information stream for processing by the new software program.