System and method for translating a first coding language to a second coding language

Abstract

A system and method for translating a first coding language to a second coding language includes the process of training a machine learning (ML) model on a first coding language-specific dataset associated with the first coding language, wherein the ML model is trained to translate one or more code sets of the first coding language to one or more corresponding code sets of the second coding language; and the process of generating various unit test cases using the ML model, wherein the unit test cases execute the one or more code sets of the second coding language in parallel with the one or more code sets of the first coding language; the process of iteratively testing and refining the ML model until a maturity threshold is reached; and, once the maturity threshold is reached, the process of containerizing the one or more code sets of the second coding language into one or more applications.

Description

[[Technical Field]]

[0001] Cross-reference of related applications This application claims priority to U.S. Provisional Patent Application No. 63 / 531,189, filed on August 7, 2023, the entire contents of which are incorporated herein by reference. [[Background Art]]

[0002] Mainframe systems have been used in the financial industry for decades, and Common Business Oriented Language (commonly known as COBOL) has been a prominent programming language since the 1960s. Thanks to decades of development and technological advancement, both mainframes and COBOL have not only provided efficient daytime and nighttime processing operations, but have also become an indispensable part of business functions. However, with the emergence of distributed systems, modern programming languages, and public cloud services, it has become increasingly difficult to secure experts in mainframe technology and COBOL, and critical institutional knowledge regarding existing implementations and business logic is also rapidly being lost in many large-scale organizations.

[0003] Current mainframe modernization techniques generally involve manually analyzing COBOL code and individually rewriting it into a modernized coding language. This process is prone to errors, requires expert resources, and takes a long time to obtain satisfactory conversions and results.

[0004] Machine learning (ML) and artificial intelligence (AI) have been in development for decades, but prior art systems have struggled to achieve meaningful results and sufficient accuracy in interpreting programming languages, converting code between different programming languages, and achieving processing equivalence.

[0005] Therefore, there is a need for systems and methods that can reduce the risks associated with large organizations operating critical business functions on legacy systems by programmatically modernizing COBOL (and other computer languages) applications and their business logic into modern programming languages ​​and optimizing processing efficiency. [Overview of the project]

[0006] Aspects of this disclosure relate to methods, apparatus, and / or systems for translating a first coding language into a second coding language.

[0007] In some embodiments, methods relating to the techniques described herein are methods for translating a first coding language to a second coding language, comprising: training a first machine learning (ML) model by a processor at least partially on a first coding language-specific dataset relating to the first coding language, wherein the first ML model is trained to translate one or more code sets of the first coding language to one or more corresponding code sets of the second coding language; generating at least one unit test case by the processor using the first ML model, wherein the at least one unit test case executes the one or more code sets of the second coding language in parallel with the one or more code sets of the first coding language; iteratively testing and refining the first ML model by the processor, at least partially based on the maturity level of the first ML model, until a maturity threshold is reached; and, once the maturity threshold is reached, containerizing the one or more code sets of the second coding language into an application by the processor.

[0008] In some embodiments, the methods relating to the techniques described herein include the first coding language-specific dataset comprising at least one of the following related to the first coding language: language reference documents, libraries, historical input files, historical output files, runtime logs, parameter sets, or control points.

[0009] In some embodiments, the methods relating to the technology described herein are such that the first coding language is Common Business Language (COBOL).

[0010] In some embodiments, the methods relating to the techniques described herein involve a second coding language being one of Java, Golang, Python, Angular, or C++.

[0011] In some embodiments, the methods relating to the techniques described herein, the first machine learning model is a natural language model (NLM).

[0012] In some embodiments, methods relating to the techniques described herein include the step of iteratively testing the first ML model, which involves performing a series of iterative regression tests based on at least one historical input data of the one or more code sets of the first coding language, and comparing the corresponding output data of the first ML model to at least one historical output of the one or more code sets of the first coding language.

[0013] In some embodiments, methods relating to the techniques described herein include the step of iteratively improving the first ML model, the step of having the processor perform one or more debugging techniques, and the step of updating the first ML model based on the one or more debugging techniques performed.

[0014] In some embodiments, the methods relating to the technology described herein further include the step of dynamically scaling one or more containerized applications by the processor at least partially based on one or more of a second ML model or at least one second unit test case that has reached the maturity threshold.

[0015] In some embodiments, the methods relating to the technology described herein further include the step of tracking the progress of the at least one test case based at least in part on the maturity level of the first ML model by the processor.

[0016] In some embodiments, a system relating to the technology described herein is a system for translating a first coding language to a second coding language, comprising a computer having a processor and memory, and one or more code sets stored in the memory and executed by the processor, which, when executed, trains a first machine learning (ML) model on a first coding language-specific dataset relating to the first coding language, wherein the first ML model is trained to translate one or more code sets of the first coding language to one or more corresponding code sets of the second coding language. The processor comprises one or more code sets, which perform the following: a process; a process of generating at least one unit test case using the first ML model, wherein the at least one unit test case executes one or more code sets of the second coding language in parallel with the one or more code sets of the first coding language; a process of iteratively testing and improving the first ML model, at least in part based on the maturity level of the first ML model, until a maturity threshold is reached; and a process of containerizing the one or more code sets of the second coding language into an application once the maturity threshold is reached.

[0017] In some embodiments, the systems relating to the technology described herein include a first coding language-specific dataset comprising at least one of the following related to the first coding language: language reference documents, libraries, historical input files, historical output files, runtime logs, parameter sets, or control points.

[0018] In some embodiments, the methods relating to the systems described herein involve a first coding language being Common Business Language (COBOL).

[0019] In some embodiments, the systems relating to the technology described herein include a second coding language which is one of Java, Golang, Python, Angular, or C++.

[0020] In some embodiments, in the systems relating to the technologies described herein, the first machine learning model is a natural language model (NLM).

[0021] In some embodiments, in a system relating to the technology described herein, when the first ML model is iteratively tested, the processor is further configured to perform a number of iterative regression tests based on at least one historical input data of the one or more code sets of the first coding language, and to compare the corresponding output data of the first ML model with at least one historical output of the one or more code sets of the first coding language.

[0022] In some embodiments, in a system relating to the techniques described herein, when the first ML model is iteratively improved, the processor is further configured to perform one or more debugging techniques and update the first ML model based on the one or more debugging techniques performed.

[0023] In some embodiments, the systems relating to the technology described herein are further configured to dynamically scale one or more containerized applications at least partially based on one or more of the second ML models or at least one second unit test case that have reached the maturity threshold.

[0024] In some embodiments, in a system relating to the technology described herein, the processor is further configured to track the progress of the at least one test case, at least in part, based on the maturity level of the first ML model.

[0025] In some embodiments, a non-temporary computer-readable medium relating to the technology described herein is a non-temporary computer-readable medium storing computer program instructions, wherein when the computer program instructions are executed by one or more processors, the one or more processors perform operations including: training a first machine learning (ML) model at least in part on a first coding language specific dataset relating to the first coding language, wherein the first ML model is trained to translate one or more code sets of the first coding language into one or more corresponding code sets of the second coding language; generating at least one unit test case using the first ML model, wherein the at least one unit test case executes the one or more code sets of the second coding language in parallel with the one or more code sets of the first coding language; iteratively testing and refining the first ML model until it reaches a maturity threshold, at least in part on the maturity level of the first ML model; and, once the maturity threshold is reached, containerizing the one or more code sets of the second coding language into an application.

[0026] In some aspects, in the non-transitory computer-readable medium to which the technology described in the present specification pertains, the first coding language is Common Business-Oriented Language (COBOL), and the second coding language is one of Java, Golang, Python, Angular, or C++.

[0027] Various other aspects, features, and advantages will become apparent by reference to the detailed description and the accompanying drawings. It is to be understood that both the foregoing summary and the following detailed description are exemplary only, and are not intended to limit the scope of the present disclosure. BRIEF DESCRIPTION OF THE DRAWINGS

[0028] [Figure 1] An exemplary system for translating a first coding language into a second coding language in accordance with at least one embodiment is shown.

[0029] [Figure 2] An example of a code translation application in accordance with at least one embodiment is shown.

[0030] [Figure 3] An exemplary method for translating a first coding language into a second coding language in accordance with at least one embodiment is shown.

[0031] [Figure 4] An example of a plain summary created based on a code set according to some embodiments is shown.

[0032] [Figure 5] An example of a legacy code set and a translated modernized code set according to some embodiments is shown.

[0033] The technology of the present invention can take on various modifications and alternative forms, specific embodiments of which are shown as examples in the drawings and described in detail herein. The drawings may not be to actual scale. However, it should be understood that the drawings and the detailed description therefrom are not intended to limit the technology to any particular form disclosed, but rather to cover all modifications, equivalents, and alternatives that fall within the spirit and scope of the technology as defined by the appended claims. [Modes for carrying out the invention]

[0034] In the following description, many specific details are provided for illustrative purposes to ensure a thorough understanding of each of the various embodiments. However, those skilled in the art will understand that embodiments of the present invention can be carried out without these specific and detailed descriptions, or with equivalent configurations. In other cases, well-known structures and devices are shown in block diagram form to avoid unnecessarily obscuring each embodiment of the present invention.

[0035] The systems and methods described herein can be implemented in numerous practical applications. For example, the advantages of using machine learning models to translate mainframe code into modernized code or microservices, as described herein, are applicable to other environments, system configurations, and even combinations of different programming languages. For instance, while the systems and methods described herein generally refer to translating COBOL to other computer programming languages ​​such as Java, those skilled in the art will understand that the same or similar techniques can be implemented to enable translation between any two computer programming languages.

[0036] To mitigate the problems described herein, the inventors needed to devise solutions and, in some cases equally important, recognize problems that others had overlooked (or had not yet foreseen) in the field of identifying, evaluating, and repairing defects. Indeed, the inventors wish to emphasize the difficulty of recognizing problems in their early stages. These problems will become far more apparent in the future if industry trends continue as the inventors predict. Furthermore, because there are multiple problems to address, it should be understood that some embodiments specialize in one of these problems, and not all embodiments address all of the problems of the conventional systems described herein, nor do they offer all of the advantages described herein. In other words, improvements that address various permutations of these problems are described below.

[0037] In embodiments, ML / AI tools are used to train a code (e.g., COBOL) translation model based on previously processed datasets and parallel runtime processing lanes, and to compare input and output data. Embodiments of the systems and methods described herein provide technical solutions for accurately translating code from one computer language to another (e.g., COBOL to Java), ensuring consistent data quality and processing iteratively. Further embodiments provide a containerized microservices architecture that achieves processing efficiency and scalability in terms of performance and resource consumption.

[0038] In this specification, a mainframe computer, abbreviated as a mainframe or Big Iron, is a computer primarily used in large organizations for critical purposes such as processing large amounts of data for tasks like censuses, industry statistics, consumer statistics, corporate resource planning, and large-scale transaction processing. The term mainframe originates from the large cabinet called a mainframe that housed the central processing unit and main memory of early computers.

[0039] Common Business Oriented Language (COBOL) is a programming language used in mainframe computing. COBOL is a compiled, English-style programming language designed for business use. COBOL is imperative, procedural, and, since 2002, object-oriented. COBOL is widely used in applications deployed on mainframe computers, including large batch processing jobs and transactional processing jobs.

[0040] Machine learning is a branch of artificial intelligence that deals with systems that can acquire unique "knowledge" by extracting patterns from raw data, rather than relying on hardcoded knowledge.

[0041] In this specification, artificial intelligence (AI) refers to the intelligence exhibited by machines (perception, synthesis, and reasoning of information), as opposed to the intelligence exhibited by non-human animals or humans. Examples of such tasks include speech recognition, computer vision, translation between (natural) languages, and mapping of other inputs.

[0042] In this specification, microservices architecture ("microservices") is a variation of service-oriented architecture. It is an architectural pattern that arranges applications as a collection of loosely coupled, fine-grained services that communicate via lightweight protocols.

[0043] Test-Driven Development (TTD) is a software development process that tracks the entire software development process by translating software requirements into test cases and repeatedly testing the software against all test cases before the software is fully developed.

[0044] Those skilled in the art will understand that the inventive concepts described herein can function in a variety of system configurations. Furthermore, various embodiments of this disclosure can be implemented in hardware, firmware, software, or any suitable combination thereof. Aspects of this disclosure may be implemented as instructions stored in a machine-readable medium that can be read and executed by one or more processors. A machine-readable medium can include any mechanism for storing or transmitting information in a format readable by a machine (e.g., a computing device, a signaling medium), and can include a machine-readable transmission medium or a machine-readable storage medium. For example, machine-readable storage media include read-only memory, random-access memory, magnetic disk storage media, optical storage media, flash memory devices, and the like. Furthermore, firmware, software, routines, or instructions can be described herein in terms of specific exemplary embodiments that can perform a particular operation. However, such descriptions are for convenience only, and it is clear that such operations are actually performed by computer devices, processors, control devices, or other devices that execute firmware, software, routines, or instructions.

[0045] As will be further detailed herein, a foundational knowledge set of the COBOL language can be constructed to generate a natural language model (NLM) for accurate COBOL-to-modern language translation. This information may be based on various COBOL language reference documents, examples, code, and / or other sources. Similarly, a foundational knowledge set of the target modern language can be constructed. Once the language foundational knowledge set is established, the NLM can process the original mainframe COBOL code, its libraries, and / or other documents and structures. At this stage of ML training, each NLM touches upon a specific COBOL application and associated datasets, deepening its understanding of its functionality and logic. In some embodiments, as described herein, the NLM can be queried to produce a plain summary of a particular part of the application, functionality, and / or logic in order to test its maturity. This stage will be beneficial in documenting organizational knowledge and laying the foundation for version-controlled code enhancement.

[0046] It should be noted that, in addition to and / or as an alternative to NLMs, other types of models capable of processing large datasets may be used in various embodiments. For example, Large-Scale Language Models (LLMs) are machine learning models featuring a vast number of parameters and requiring significant computational resources for training and inference. These models are often designed to handle complex, high-dimensional data and can capture intricate patterns and relationships within the data. LLMs are often based on deep learning architectures such as deep neural networks, convolutional neural networks (CNNs), and transformer models. Other models include, for example, rule-based natural language processing (NLP) systems, template-based systems, Bag-of-Words algorithms, N-Gram models, and latent semantic analysis (LSA) models. Each of these additional / alternative models to natural language models has its own use cases and limitations. Thus, in various embodiments, the systems and methods described herein may be configured to implement different models to achieve different results based on the requested translation.

[0047] In the next stage of NLM training, embodiments may include progressively translating COBOL code into a modern language such as Java, Golang, or Angular. In some embodiments, the system is configured to recommend the best modern language to use based on the intended use case and architectural requirements or other criteria. For example, if the intended use case involves mobile devices (e.g., Apple® or Android®), the system may be configured to translate a first coding language into a second coding language that is most appropriate based on its capabilities, performance, environment, and / or experience. In some embodiments, as part of the initial translation, the NLM may be instructed to generate unit test cases following a test-driven development approach. This approach can help build a stepwise and accurate output of the data processed by the translated code. In various embodiments, the translated modernized code may undergo rigorous regression testing, comparing the output data to the output of the original COBOL code based on historical input data, for example. The translated code may include additional (or similar) logs, parameters, and / or control points that the NLM may use to debug inconsistencies in the output dataset. By incrementally debugging and refining the translated, modernized code, it may be possible to achieve higher fidelity in output data processing across both granular and functional modules.

[0048] In some embodiments, once the modernized code achieves high fidelity, for example, based on a predetermined threshold or test, a pre-production parallel environment can be established to enable simultaneous processing of production input data. Both lanes may be designed to record intermediate data points, variables, values, etc., which, in some embodiments, can be utilized in post-processing to enhance debugging. Parallel execution may generate multiple, for example, two, output data / results, which may be compared and identified if inconsistencies occur. In some embodiments, the NLM may continue to be strengthened while the modernized code is continuously updated to achieve threshold consistency (e.g., 100% consistency) until the output data / results are identical or sufficiently similar to reach a predefined similarity threshold. In some embodiments, the strengthened modernized code may be retested with historical data to ensure reasonable backward compatibility and processing results.

[0049] In some embodiments, once the modernized code achieves acceptable data accuracy and performance, for example, based on predefined thresholds, the modernized code may be further segmented into microservices code. The modernized code and / or subsections of its functionality can be measured for processing frequency and execution time. Various logs, parameters, and variables can be introduced to measure and track usage. Such information can be collected in a separate performance database to record behavioral metrics and show trends.

[0050] In some embodiments, as part of developing modernized code and data processing flows, the systems and methods described herein can determine whether input data is processed serially / sequentially, as opposed to using indexable values. The intended modernized processing logic may also determine whether it is possible to horizontally scale (e.g., multithread) the modernized microservice functionality and / or increase resource capacity so that an optimized processing service level agreement (SLA) is achieved.

[0051] In some embodiments, the performance database may also be configured to record the number of data volumes, transactions, size, and / or processing speed for each phase of daytime or nighttime processing, so that multiple (e.g., any) layers of modernized and / or microservice code can scale horizontally and / or dynamically in anticipation of known and incoming transaction volumes from upstream systems. Furthermore, dynamic scaling may also calculate and determine the additional resources required to meet future SLAs and allocate additional resources in advance as needed. These and other features are described in detail herein.

[0052] Figure 1 shows an exemplary system for translating a first coding language to a second coding language according to at least one embodiment. As shown in Figure 1, the system 100 may comprise user device 122, user device 124, mainframe 160, and / or other components. Each user device and / or mainframe 160 may include any type of mobile terminal, fixed terminal, or other device. Each device may receive content and data via input / output (hereinafter, "I / O") paths and may further include a processor and / or control circuit that sends and receives commands, requests and other appropriate data using the I / O paths. The control circuit can consist of any appropriate processing circuit. Each device may further include a user input interface and / or display used for receiving and displaying data. For example, user devices 122 and / or 124 can be any computer or computing device, including, but not limited to, laptop computers, tablet computers, handheld computers / computing devices, and other computer equipment (e.g., servers) (including "smart," wireless, wearable, and / or mobile devices), which include a processor such as processor 112. Processor 112 may include one or more of the following: a digital processor, an analog processor, a digital circuit for information processing, an analog circuit for information processing, a state machine, and / or other mechanisms for electronically processing information. Processor 112 is shown as a single entity in Figure 1, but this is for illustrative purposes only. In some embodiments, processor 112 includes multiple processing units. These processing units may be located in the same physical device, or processor 112 may represent the processing functions of multiple devices working together.

[0053] The processor 112 may use software, hardware, firmware, software, hardware, and / or firmware, and / or other mechanisms to constitute processing power on the processor 112 when executing or implementing one or more functions of the code translation application 114 (shown in detail in Figure 2). Although the functions of the code translation application 114 are illustrated to be in close proximity within the user device 124 in Figure 2, it should be understood that one or more components or functions of the code translation application 114 may be located far apart from other components or functions. The descriptions of the functions provided by the various components or features of the code translation application 114 described below are illustrative, and it is possible that any component or feature of the code translation application 114 may provide more or fewer functions than described, and this does not mean that the other descriptions are limiting. For example, one or more components or features of the code translation application 114 may be omitted, and some or all of their functions may be provided by other components or features of the code translation application 114, and this does not mean that the other descriptions are limiting. As another example, the processor 112 may include one or more additional components that can perform some or all of the functions described below as components or features of the code conversion application 114.

[0054] In some embodiments, the processor 112 may be programmed to execute one or more computer program components. These computer program components or functions may include, for example, software programs and / or algorithms coded and / or otherwise embedded in the computer 112. These one or more computer program components or functions may include the functions of the code translation application 114.

[0055] A user may, for example, use one or more user devices to interact with each other, with one or more servers, or with other components of System 100. While one or more processes are described herein as being performed by specific components of System 100, it should be noted that in some embodiments, these processes may be performed by other components of System 100. For example, one or more processes described herein as being performed by a component of user device 124, including processor 112, may in some embodiments be performed by a component of user device 122 and / or mainframe 160. System 100 may also include cloud-based components 110, including cloud server 102, which may have services implemented on user device 122, user device 124, or mainframe 160, and / or be accessible by communication paths 128, 130, 132, 134, or 136, respectively. Conversely, user devices 122, 124, and / or the mainframe 160 can access the cloud-based components 110 via communication paths 128, 130, 132, 134, and / or 136. System 100 can receive data from remote servers (e.g., server 108) and / or databases (e.g., databases 104, 106). It should also be noted that the cloud-based components in Figure 1 may, alternatively and / or additionally, be non-cloud-based components. Additionally or alternatively, one or more components may be combined, replaced, and / or used alternately. For example, system 100 may include databases 104, 106, and server 108 that can provide data to cloud server 102.

[0056] System 100 may also include a dedicated network server (e.g., network server 150) that can function as a network gateway, router, and / or switch. Network server 150 may additionally or alternatively include one or more components of a cloud-based component 110 for translating a first coding language to a second coding language. Network server 150 may consist of network hardware used to allow data to flow from one individual domain to another. Network server 150 may use multiple protocols (as opposed to routers and switches) to connect multiple networks and / or domains and may operate in any of the seven layers of the Open Systems Interconnection Model (OSI). It should also be noted that the functions and / or features of network server 150 may be incorporated into one or more other components of system 100, and the functions and / or features of system 100 may be incorporated into network server 150.

[0057] System 100 may further include a mainframe (e.g., mainframe 160). As mentioned here, a mainframe is a high-performance, large-scale computer system designed to handle massive workloads and process large amounts of data simultaneously. Mainframes typically serve as the central backbone for handling critical applications and services in industries such as banking, finance, government, and large enterprise environments. Mainframes typically employ a symmetric multiprocessing (SMP) architecture, where multiple processors operate in parallel to execute instructions. They also employ specialized hardware components such as channel subsystems, I / O processors, and channel pathways to efficiently manage input / output operations. Mainframe computers are primarily used in large organizations for critical applications such as processing large amounts of data for tasks like censuses, industry statistics, consumer statistics, corporate resource planning, and large-scale transaction processing. Mainframes are used as record systems in many organizations. Batch and online transactions processed on mainframes are often used by critical systems both inside and outside the mainframe for daily business processes and operations. The mainframe 160 may run enterprise software and / or other computer operating code, collectively referred to as legacy code sets 116, such as COBOL, which may be difficult to directly integrate with other modernized computer code, such as Java, which runs in a distributed environment. Therefore, embodiments can enable the translation of a first coding language into a second coding language, as described herein.

[0058] Server 108 can execute modernized computer code programmed to run in a distributed environment such as Java, for example, a modernized code set 118. Databases 104 and 106 can each contain coding language-specific datasets 144 and 146, respectively. As described in detail herein, embodiments can train one or more machine learning and / or AI models on at least in part to various coding language-specific datasets.

[0059] Each device of System 100 may also include memory in the form of an electronic storage device. The electronic storage device may include non-temporary storage media that electronically store information. Among the media, electronic storage may include (i) system storage provided integrally with the server or client device (e.g., substantially inremovably), and / or (ii) removable storage that is detachably connected to the server or client device via, for example, a port (e.g., a USB port, a FireWire port, etc.) or a drive (e.g., a disk drive, etc.). Electronic storage may include optically readable storage media (e.g., optical discs, etc.), magnetically readable storage media (e.g., magnetic tape, magnetic hard drives, floppy drives, etc.), charge-type storage media (e.g., EEPROM, RAM, etc.), solid-state storage media (e.g., flash drives, etc.), and / or other electronically readable storage media. Electronic storage may also include virtual storage resources (e.g., cloud storage, virtual private networks, and / or other virtual storage resources). Electronic storage may store software algorithms, information determined by the processor, information obtained from a server, information obtained from a client device, or other information that enables the functions described herein.

[0060] Figure 1 may also include communication paths 128, 130, 132, 134, and / or 136. Communication paths 128, 130, 132, 134, and / or 136 may include the Internet, a cellular network, a mobile voice network or mobile data network (e.g., a 5G network or LTE network), a cable network, a public switched telephone network, or other types of communication networks or a combination of multiple communication networks. Communication paths 128, 130, 132, 134, and / or 136 may include one or more communication paths, such as a satellite path, a fiber optic path, a cable path, Internet communications (e.g., IPTV), free-space connectivity (e.g., for broadcast or other radio signals), or any other suitable wired or wireless communication path or a combination thereof. The computing device may further include communication paths connecting multiple hardware components, software components, and / or firmware components that cooperate. For example, the computing device may be implemented by multiple computing platforms that cooperate as a computing device.

[0061] Figure 2 shows an example of a code translation application, such as a code translation application 114 for a user device 124 (Figure 1), according to at least one embodiment. In some embodiments, the code translation application 114 may include components such as historical input / output data 202, runtime logs / runtime log / parameter control 204, an AI / ML training model 206, a test case module 208, a comparison / improvement module 210, and / or a subdivision module 212. While these components are shown as being included in the user device 124, in various embodiments, one or more of these components may reside in and / or be accessible through other elements of the system 100. In some embodiments, the input / output data 202 may be historical data entered as prompts into the code translation application 114, and / or historical data output as a result from the code translation application 114. The input includes prompts and / or other codes entered into the system to elicit a response from the system. In some embodiments, the runtime log / parameter control 204 may include various details and information regarding legacy code (e.g., legacy code set 116) and / or modernized code (e.g., modernized code set 118). These details and information may include runtime information, metadata, configurations, and other parameters related to the various code sets. Such information can be used for analysis or other methods to extract further information about the various code sets or to improve training.

[0062] In some embodiments, the AI / ML training model 206 can represent one or more training models developed by employing AI and / or ML techniques and / or tools. For example, in some embodiments, the AI / ML training model 206 may be one or more natural language models (NLMs) that can be trained to accurately generate new, modernized code based on older legacy code, as described herein. In some embodiments, the test case module 208 can enable test-driven development (TDD) for the newly generated software code. Thus, the test case module 208 can enable the translation of predefined software requirements into test cases before the software is fully developed, and / or track the development of the software by repeatedly testing the software against other (e.g., all) test cases. A threshold can be set that defines an initial fidelity level for the generated code. The test case module 208 can then detect when the generated code has reached the threshold and, for example, send an alert to the user of user device 124.

[0063] In some embodiments, the comparison / improvement module 210 may be configured to allow the code translation application 114 to improve the generated code for production use. As described herein, once the modernized code reaches a threshold fidelity, the embodiment may be configured to run the code as pre-production code in parallel with the production input code. The results of each code set are compared, and the pre-production code is iteratively improved, for example, until it is ready for production (for example, until the legacy code can be replaced with the translated modernized code). In some embodiments, the subdivision module 212 may then be implemented to subdivide a subset of the modernized code into one or more containerized applications or programs (hereinafter referred to as "microservices"). Additionally or alternatively, the subdivision module 212 may allow the code translation application 114 to scale the modernized code horizontally and / or vertically, as described herein. These and other features are described in further detail herein.

[0064] Figure 3 shows an exemplary method 300 for translating a first coding language to a second coding language according to at least one embodiment. In various embodiments, the method 300 may be implemented by a system 100 in which one or more processors execute the code. For example, in some embodiments, the method 300 may be implemented on a computer (e.g., user device 124) having one or more processors and memory (not shown), and one or more sets of code, applications, programs, modules, and / or other software (e.g., such as the code translation application 114 in Figure 2) that are stored in the memory and executed in or by the processors.

[0065] Method 300 begins with step 310, where the processor is configured to train a first machine learning (ML) model on a first coding language-specific dataset that is at least partially related to a first coding language. To generate an accurate natural language model (NLM) for a legacy code set (such as COBOL), embodiments train or otherwise access a legacy language knowledge set. This information can be based on various language reference documents, samples, examples, code, and / or other sources (e.g., internal and / or external database libraries and resources), historical input files, historical output files, runtime logs, parameter sets, and / or control points related to the first coding language. Similarly, in some embodiments, the processor may be configured to train a second ML model using a modern language knowledge set for a target modern language (e.g., Java, Golang, Python, Angular, and / or C++). In some embodiments, translation between coding languages ​​can be further enhanced by developing separate models for each language. For example, this could enable backtranslation to test accuracy or parallel execution for comparison purposes.

[0066] In some embodiments, before processing the first coding language with the first ML model, variables, subfunctions, and / or other source code (e.g., dead code and / or unreachable code) that are not required or referenced by the program can be excluded and / or commented out. Similarly, in some embodiments, before processing the second coding language with the second ML model, variables, subfunctions, and / or other source code (e.g., dead code and / or unreachable code) that are not required or referenced by the program can be excluded and / or commented out.

[0067] In some embodiments, before processing the first coding language with the first ML model, all relevant copybooks, libraries, header files, etc. referenced in the source code may be incorporated into and / or expanded in the source code. Similarly, in some embodiments, before processing the second coding language with the second ML model, all relevant copybooks, libraries, header files, etc. referenced in the source code may be incorporated into and / or expanded in the source code.

[0068] In various embodiments, training of an ML model may be carried out using one or more of a number of machine learning and / or AI techniques. For example, an embodiment may use existing tools to train one or more word embeddings based on data specific to each coding language. Existing tools include, for example, algorithms that learn word embeddings by predicting contextual words given a target word (Continuous Bag of Words (CBOW)) or by predicting a target word given its context (Skip-gram); unsupervised learning algorithms that learn word embeddings by combining global matrix decomposition techniques with local context window-based methods; and algorithms that handle out-of-vocabulary words using subword information (character n-grams). As understood herein, word embeddings are a general term for language modeling and feature learning techniques in natural language processing (NLP) that map words or phrases from a given vocabulary to real-valued vectors. Conceptually, this means a mathematical embedding from a one-dimensional space per word to a lower-dimensional continuous vector space. In some embodiments, one or more of these NLP techniques may be implemented to create word embeddings that can inform the ML model of Method 300. Those skilled in the art will recognize that many different ML / AI training tools can be used to train ML models. For example, in various embodiments, one or more of the following techniques may be applied to train an ML model: sentiment analysis, named entity recognition, summarization, topic modeling, text classification, keyword extraction, rematization and stemming, and other NLP, ML, and / or AI techniques.

[0069] In some embodiments, once an underlying language knowledge set is established for a given language, the processor can enable the NLM to process a first coding language (e.g., a legacy code set such as mainframe COBOL code), its libraries, and any other arbitrary documents and structures. During this phase of ML training, the NLM can deepen its own understanding of the functionality and logic of a legacy code set by interacting with a specific legacy application (e.g., a COBOL code set) and associated datasets. In some embodiments, to test the maturity of the NLM, the processor may be configured to create or otherwise generate a plain summary of a specific part of the legacy code set (e.g., a COBOL application), including, for example, functions, logic, etc., for a predefined threshold of maturity. This process would be beneficial in documenting organizational knowledge and laying the foundation for version-controlled code hardening. Figure 4 shows an example of a plain summary 410 created based on a COBOL code set 420.

[0070] In step 320, in some embodiments, the processor can translate one or more code sets of a first coding language into one or more corresponding code sets of a second coding language. For example, in some embodiments, the processor may be configured to receive or acquire a legacy code set (e.g., a COBOL code set) and use one or more ML models to translate the legacy code set into a modernized code set (e.g., Java, Go-lang, Angular, etc.). As described above, in various embodiments, one or more AI / ML training models may be used to identify text, functions, logic, and other information from the first code set and translate the first code set into a second code set, with the intention that the newly generated code set be functionally and logically equivalent to the original code set as much as possible. In some embodiments, the processor may be configured to progressively and / or iteratively convert the legacy code set to a modern coding language as described herein and monitor the process. Figure 5 shows examples 500 of a legacy code set 510 and a translated modernized code set 520, according to several embodiments.

[0071] In step 330, in some embodiments, the processor may generate at least one unit test case using a first ML model. As part of the translation / transformation process, in some embodiments, the processor may employ NLM to generate one or more unit test cases following a test-driven development methodology. This approach may help build a stepwise and accurate output of the data processed by the translated code. In some embodiments, the translated modernized code may undergo rigorous testing, including regression testing based on historical input data and comparison of the output data to the output of the original code set.

[0072] In some embodiments, the processor can track the progress of at least one test case, at least partially based on the maturity level of the first ML model. For example, various metrics such as processing time, processing power consumption, processing efficiency, output accuracy, and memory consumption can be tracked and compared to predefined thresholds. In some embodiments, the translated model may include additional and / or similar logs, parameters, and control points, similar to the legacy model, and the processor can leverage the NLM to debug any inconsistencies in the output dataset. By incrementally debugging and refining the translated, modernized code, fidelity to output data processing can be achieved at both the granularity and feature levels.

[0073] In step 340, in some embodiments, the processor can execute one or more code sets of a second coding language in parallel with one or more code sets of a first coding language. In some embodiments, once the modernized code sets achieve high fidelity, for example with respect to one or more predefined thresholds, the processor can execute or otherwise establish a pre-production parallel environment to enable concurrent processing in parallel with production input data. By analyzing the outputs of the legacy code set (production environment) and its translated modernized code set (pre-production environment) in parallel and substantially in real time, the system can identify and / or address problems in the translated code set and further refine the respective training models. In some embodiments, both lanes may be designed to record intermediate data points, variables, values, etc., which can be utilized in post-processing to enhance debugging. In some embodiments, both code sets running in parallel can be displayed, and a user interface may be provided that allows the user to edit the pre-production code, for example in real time, to provide input for bugs or problems to be addressed (in the code and / or ML model), fix them, or flag them otherwise.

[0074] In step 350, in some embodiments, the processor can iteratively test and refine the first ML model, at least in part, based on the maturity level of the first ML model, until it reaches a maturity threshold. In some embodiments, the processor can perform multiple iterative regression tests on a newly translated, modernized code set run in a pre-production environment, based on at least one historical input data of one or more code sets of a first coding language (e.g., COBOL), and compare the corresponding output data of the first ML model to at least one historical output of one or more code sets of the first coding language.

[0075] In some embodiments, the processor may execute one or more debugging techniques and update the first ML model based on the one or more executed debugging techniques. In some embodiments, parallel execution may generate sets of output data / results, which can be compared to identify any inconsistencies. In some embodiments, the NLM may continue to be strengthened until the output data / results are identical or fall within a predefined tolerance range, and the modernized code set may continue to be updated to achieve, for example, 100% consistency (or a predefined consistency / precision). In some embodiments, the strengthened modernized code may be retested with historical data, for example, periodically or periodically, to ensure reasonable backward compatibility and processing results. In some embodiments, one or more debugging techniques may be enabled for the first coding language to build and / or model a typical sequential operation order of the program execution flow.

[0076] In step 360, in some embodiments, the processor may, upon reaching a maturity threshold, containerize one or more sets of code in a second coding language into an application. For example, in some embodiments, once the processor determines that a modernized set of code has achieved acceptable data accuracy and / or performance, e.g., accuracy and / or performance that meet predefined criteria, metrics, and / or thresholds, the modernized set of code may be further segmented into one or more programs, applications, or other containerized sets of code, collectively referred to as microservices code. In some embodiments, the modernized set of code and / or subsections of its functionality may be measured for key metrics such as processing frequency and execution time. In some embodiments, various logs, parameters, variables, etc., may be placed and their use measured and tracked, for example, for quality control purposes. Such information may be collected in, for example, a separate performance database to record behavioral metrics and show trends. Additionally or alternatively, such information may also be fed back into an ML model to further optimize the model and its resulting output.

[0077] In some embodiments, as part of developing a modernized codeset and data processing flow, the processor may be configured to determine whether input data to the code is processed serially / sequentially or using indexable values. The intended modernized processing logic may determine whether it is possible to horizontally scale (e.g., multithread) and / or increase resource capacity for microservice functionality generated from the modernized codeset, for example, to achieve an optimized processing SLA. In some embodiments, the processor may be configured to identify and / or recommend additional implementations for containerized microservices generated from the modernized codeset, for example, across different platforms and / or for different services.

[0078] In some embodiments, the processor may be configured to record, for example, the number of data volumes, transactions, size, and / or processing speed of various microservices and applications generated from the modernized code set in a performance database. Thus, in each phase of daytime or nighttime processing, each layer of the modernized code set and / or microservice code set can be horizontally scaled and / or dynamically scaled in anticipation of a known volume of incoming transactions from the upstream system. In some embodiments, dynamic scaling may also calculate and determine the additional resources required to meet future SLAs. In some embodiments, the processor may implement an ML model to determine the dynamic scaling algorithm based on how the original processing (e.g., top-down (FIFO) or multithreaded or some index on a key dataset) was performed.

[0079] In some embodiments, the processor may utilize an ML model to measure the processing throughput performance of dynamically scalable logic and / or to proactively scale downstream processing based on upstream volume signals. When a new modernized code set is developed, in some embodiments, the processor may be configured to document, tag, or otherwise reference (e.g., in a library database) the functionality and / or other details of the modernized code set and / or the containerized microservices created therefrom. Thus, when a new service or functionality is requested, in some embodiments, the processor may be configured to look up the relevant code set in which it may be located.

[0080] In some embodiments, the processor may be configured to provide translation recommendations. For example, in some embodiments, a trained ML model may be configured to recommend a target language for a given legacy language based on a desired use case, a target system / platform, and required functionality. For instance, the processor may identify a segment of COBOL mainframe code suitable for translation and implementation as a Java application or microservice and recommend the execution of the system and method described herein for the purpose of creating a modernized code set.

[0081] In some embodiments, the processor can dynamically scale one or more containerized applications based, for example, on a second ML model that has reached a maturity threshold (e.g., a second modernized coding language, an ML model for prioritizing containerized code sets) or at least partially on one or more of at least one second unit test case. As described above, in some embodiments, the processor may be configured to implement further AI and / or ML tools to learn from the results of prior translations, perform further tests using, for example, additional unit test cases, and generate further recommendations and / or improvements. Such recommendations and / or improvements can be automatically integrated into any of the processes described above to further improve the system described herein.

[0082] While the systems and methods described herein have generally described the translation of a single legacy language into a modernized coding language (e.g., a one-to-one translation from a first language to a second language), in various embodiments the same process can be implemented in a one-to-many framework. For example, in some embodiments, a user can specify one or more second languages ​​to translate from the first language. Additionally or alternatively, in some embodiments, one or more translation recommendations may be provided for multiple translations (as described herein). In any case, embodiments of the systems and methods described herein may be configured to process multiple translations, for example, in parallel and / or serially (e.g., based on identified priorities), as described herein.

[0083] The examples used in this document are intended to disclose embodiments, including best modes, and to enable any person skilled in the art to practice the embodiments, including the manufacture and use of any device or system and the execution of any incorporated methods. The patentability of this disclosure is defined by the claims and may include other embodiments that a person skilled in the art may conceive. Such other examples are intended to be included in the claims if they have structural elements that are not different from the language of the claims, or if they include equivalent structural elements that are substantially different from the language of the claims. [Note 1] A method for translating a first coding language to a second coding language, comprising: training a first machine learning (ML) model by a processor at least partially on a first coding language-specific dataset relating to the first coding language, wherein the first ML model is trained to translate one or more code sets of the first coding language to one or more corresponding code sets of the second coding language; generating at least one unit test case by the processor using the first ML model, wherein the at least one unit test case executes the one or more code sets of the second coding language in parallel with the one or more code sets of the first coding language; iteratively testing and improving the first ML model by the processor, at least partially based on the maturity level of the first ML model, until a maturity threshold is reached; and, once the maturity threshold is reached, containerizing the one or more code sets of the second coding language into an application by the processor. [Note 2] The method described in [Appendix 1], wherein the first coding language-specific dataset comprises at least one of the following related to the first coding language: language reference documents, libraries, historical input files, historical output files, runtime logs, parameter sets, or control points. [Note 3] The first coding language is the Common Business Language (COBOL), as described in [Appendix 1]. [Note 4] The method described in [Appendix 1], wherein the second coding language is one of Java, Golang, Python, Angular, or C++. [Note 5] The first machine learning model is a natural language model (NLM), as described in [Appendix 1]. [Note 6] The method according to [Appendix 1], wherein the step of iteratively testing the first ML model includes performing a series of iterative regression tests based on at least one historical input data of the one or more code sets of the first coding language, and comparing the corresponding output data of the first ML model with at least one historical output of the one or more code sets of the first coding language. [Note 7] The method according to [Appendix 6], wherein the step of iteratively improving the first ML model includes the steps of: performing one or more debugging techniques by the processor; and updating the first ML model based on the one or more debugging techniques performed. [Note 8] The method according to [Appendix 1], further comprising the step of dynamically scaling one or more containerized applications based at least partially on one or more of a second ML model or at least one second unit test case that has reached the maturity threshold, using the processor. [Note 9] The method according to [Appendix 1], further comprising the step of tracking the progress of the at least one test case based at least in part on the maturity level of the first ML model using the processor. [Note 10] A system for translating a first coding language to a second coding language, comprising: a computer having a processor and memory; one or more code sets stored in the memory and executed by the processor, which, when executed, train a first machine learning (ML) model on a first coding language-specific dataset relating to the first coding language, wherein the first ML model is trained to translate one or more code sets of the first coding language to one or more corresponding code sets of the second coding language; a system for generating at least one unit test case using the first ML model, wherein the at least one unit test case executes the one or more code sets of the second coding language in parallel with the one or more code sets of the first coding language; a system for iteratively testing and improving the first ML model, at least partially based on the maturity level of the first ML model, until a maturity threshold is reached; and, once the maturity threshold is reached, containerizing the one or more code sets of the second coding language into an application, wherein the processor is configured to perform these processes. [Note 11] The system described in [Appendix 10] comprises at least one of the following related to the first coding language: language reference documents, libraries, historical input files, historical output files, runtime logs, parameter sets, or control points. [Note 12] The first coding language is the Common Business Processing Language (COBOL), as described in [Appendix 10]. [Note 13] The aforementioned second coding language is one of the following systems: Java, Golang, Python, Angular, or C++, as described in [Appendix 10]. [Note 14] The first machine learning model is a natural language model (NLM), as described in [Appendix 10]. [Note 15] The system as described in [Appendix 10], wherein when the first ML model is iteratively tested, the processor is further configured to perform a number of iterative regression tests based on at least one historical input data of the one or more code sets of the first coding language, and to compare the corresponding output data of the first ML model with at least one historical output of the one or more code sets of the first coding language. [Note 16] The system as described in [Appendix 15], wherein when iteratively improving the first ML model, the processor is further configured to perform one or more debugging techniques and update the first ML model based on the one or more debugging techniques performed. [Note 17] The system as described in [Appendix 10], wherein the processor is further configured to dynamically scale one or more containerized applications based at least partially on one or more of a second ML model or at least one second unit test case that has reached the maturity threshold. [Note 18] The system as described in [Appendix 10], wherein the processor is further configured to track the progress of the at least one test case, at least in part, based on the maturity level of the first ML model. [Note 19] A non-temporary computer-readable medium for storing computer program instructions, wherein when the computer program instructions are executed by one or more processors, the non-temporary computer-readable medium causes the one or more processors to perform operations including: training a first machine learning (ML) model at least partially on a first coding language-specific dataset associated with the first coding language, wherein the first ML model is trained to translate one or more code sets of the first coding language into one or more corresponding code sets of the second coding language; generating at least one unit test case using the first ML model, wherein the at least one unit test case executes the one or more code sets of the second coding language in parallel with the one or more code sets of the first coding language; iteratively testing and improving the first ML model at least partially based on the maturity level of the first ML model until a maturity threshold is reached; and, once the maturity threshold is reached, containerizing the one or more code sets of the second coding language into an application. [Note 20] The first coding language is Common Business Language (COBOL), and the second coding language is one of Java, Golang, Python, Angular, or C++, as described in [Appendix 19], for a non-temporary computer-readable medium.

Claims

1. A method for translating a first coding language to a second coding language, A process comprising: training a first machine learning (ML) model using a processor, at least in part, on a first coding language-specific dataset related to the first coding language, wherein the first ML model is trained to translate one or more code sets of the first coding language into one or more corresponding code sets of the second coding language; A step of generating at least one unit test case by the processor using the first ML model, wherein the at least one unit test case executes one or more code sets of the second coding language in parallel with the one or more code sets of the first coding language. The process involves the processor iteratively testing and improving the first ML model, at least partially based on the maturity level of the first ML model, until a maturity threshold is reached. When the maturity threshold is reached, the processor performs the steps of: containerizing one or more code sets of the second coding language into an application; A method for providing this.

2. The method according to claim 1, wherein the first coding language-specific dataset comprises at least one of the following related to the first coding language: language reference documents, libraries, historical input files, historical output files, runtime logs, parameter sets, or control points.

3. The method according to claim 1, wherein the first coding language is Common Business Language (COBOL).

4. The method according to claim 1, wherein the second coding language is one of Java, Golang, Python, Angular, or C++.

5. The method according to claim 1, wherein the first machine learning model is a natural language model (NLM).

6. The method according to claim 1, wherein the step of iteratively testing the first ML model includes performing a plurality of iterative regression tests based on at least one past input data of the one or more code sets of the first coding language, and comparing the corresponding output data of the first ML model with at least one past output of the one or more code sets of the first coding language.

7. The process of iteratively improving the first ML model is as follows: The process of performing one or more debugging techniques using the aforementioned processor, A step of updating the first ML model based on one or more debugging techniques that have been executed. The method according to claim 6, including the method described in claim 6.

8. The method according to claim 1, further comprising the step of dynamically scaling one or more containerized applications using the processor, at least partially based on one or more of a second ML model or at least one second unit test case that has reached the maturity threshold.

9. The method according to claim 1, further comprising the step of tracking the progress of the at least one test case based at least in part on the maturity level of the first ML model using the processor.

10. A system for translating a first coding language to a second coding language, A computer having a processor and memory, One or more code sets stored in the memory and executed by the processor, when executed, The process includes, at least in part, training a first machine learning (ML) model on a first coding language-specific dataset associated with the first coding language, wherein the first ML model is trained to translate one or more code sets of the first coding language into one or more corresponding code sets of the second coding language. A process for generating at least one unit test case using the first ML model, wherein the at least one unit test case executes one or more code sets of the second coding language in parallel with the one or more code sets of the first coding language. A process of iteratively testing and improving the first ML model, at least in part based on the maturity level of the first ML model, until a maturity threshold is reached. When the maturity threshold is reached, the process of containerizing one or more code sets of the second coding language into an application is initiated. One or more code sets that configure the processor to perform the following: A system equipped with these features.

11. The system according to claim 10, wherein the first coding language-specific dataset comprises at least one of the following related to the first coding language: language reference documents, libraries, historical input files, historical output files, runtime logs, parameter sets, or control points.

12. The system according to claim 10, wherein the first coding language is the Common Business Processing Language (COBOL).

13. The system according to claim 10, wherein the second coding language is one of Java, Golang, Python, Angular, or C++.

14. The system according to claim 10, wherein the first machine learning model is a natural language model (NLM).

15. When the first ML model is iteratively tested, the processor further: Based on at least one historical input data of the one or more code sets of the first coding language, multiple iterative regression tests are performed, and the corresponding output data of the first ML model is compared with the at least one historical output of the one or more code sets of the first coding language. The system according to claim 10, configured as follows.

16. When the first ML model is iteratively improved, the processor further: Perform one or more debugging techniques, The first ML model is updated based on one or more debugging techniques that have been performed. The system according to claim 15, configured as described above.

17. The system according to claim 10, wherein the processor is further configured to dynamically scale one or more containerized applications based at least partially on one or more of a second ML model or at least one second unit test case that has reached the maturity threshold.

18. The system according to claim 10, wherein the processor is further configured to track the progress of the at least one test case, at least in part, based on the maturity level of the first ML model.

19. A non-temporary computer-readable medium for storing computer program instructions, wherein when the computer program instructions are executed by one or more processors, the one or more processors... The process includes, at least in part, training a first machine learning (ML) model on a first coding language-specific dataset associated with the first coding language, wherein the first ML model is trained to translate one or more code sets of the first coding language into one or more corresponding code sets of the second coding language. A process for generating at least one unit test case using the first ML model, wherein the at least one unit test case executes one or more code sets of the second coding language in parallel with the one or more code sets of the first coding language. A process of iteratively testing and improving the first ML model, at least in part based on the maturity level of the first ML model, until a maturity threshold is reached. When the maturity threshold is reached, the process of containerizing one or more code sets of the second coding language into an application is initiated. A non-temporary computer-readable medium that enables the execution of actions including [specific actions].

20. The first coding language is the Common Business Processing Language (COBOL), The second coding language is one of Java, Golang, Python, Angular, or C++. The non-temporary computer-readable medium according to claim 19.

Images