Description:FORM 2

THE PATENTS ACT, 1970
(39 of 1970)
&
THE PATENT RULES, 2003

COMPLETE SPECIFICATION
(See Section 10 and Rule 13)

Title of invention:
CODE MODERNIZATION SYSTEM AND THE METHOD THEREOF

Applicant:
KLIMBER TECHNOLOGIES PRIVATE LIMITED
A company Incorporated in India under the Companies Act, 1956
Having address:
18-B, Vaibhav Nagar, Kanadia Road,
Indore - 452016, Madhya Pradesh, India

The following specification particularly describes the invention and the manner in which it is to be performed

CROSS-REFERENCE TO RELATED APPLICATIONS AND PRIORITY
[001] The present application does not claim priority from any patent application.
TECHNICAL FIELD
[002] The present subject matter described herein, relates to applications that are hosted in on premise or cloud-based data lakes or data warehouses. Particularly, the present invention relates to the automatic transformation of a code or a piece of code from a source technology to a target technology.
BACKGROUND OF THE INVENTION
[003] Organizations need to update their technology due to changes in their business needs or upgrade to new versions of technology or update to altogether new technology or due to combination of one or more of the above reasons. Predominantly, organizations implement their use cases using applications (also called workloads or use cases or code logics containing statements or instructions of code) that run on in-premise data lakes, in-premise data warehouses, in-premise lake houses, cloud data lakes, cloud lake houses or cloud-based data warehouses or combination of cloud and in-premise locations. With the advent of new versions of the same technology or the advent of an entire new technology, there is a consistent need to modernize the application (code logic). Modernization transforms a code or a piece of code from a source technology to a target technology.
[004] Modernization of code-logic from source technology to target technology often requires a manual approach or an automated approach or a combination of manual and automated approach, which involves per statement or block of statements transformation, where one unit of code is transformed into a new unit of code that usually performs the same operation. However, as of today, automated modernization or manual solutions still suffer from unacceptable limitations such as extensive use of code or data volume, huge investment of time, money, development engineering resource and steep learning of the target technology. Therefore, even if a code modernization system may create the desired transformation, it may be too costly, laborious and error prone to invest in specific modernization products.
[005] Modernization involves modifying the code, changing part of the code or the whole of the code, and/or rewriting it in a new way. There is consequently a need for a system and method to modernize the application (hence code instructions of the application) to automatically transform the code logics, which are fully compliant with the target technology, are no longer laborious, expensive, and are no longer error prone. To solve these problems, it has been proposed to transform code logic from the source technology to a latest target technology with wider acceptance.
[006] Hence, to overcome the previously mentioned drawbacks an efficient and economical code modernization system using a late fusion of a hosted vector with a foundational model is invented and presented.
OBJECTS OF THE INVENTION
[007] Main object of the present disclosure is to provide new and efficient code modernization system using a combination of a hosted vector with a foundational model hosted in on premise or cloud-based data lakes or data warehouses, governed by the construct of the target technology.
[008] Another object of the present disclosure is to provide a code modernization system and method that uses individually or a combination of both a code vectorised foundational model pre-trained on open-source code repositories and/or proprietary code repositories and a customized vector database to modernize applications from a source platform or programming language or version to a target platform, language, or version of a particular programming language. Particularly, the present disclosure provides a code modernization system for modifying the code, changing part of the code, or changing the whole code, and rewriting it in a new way.
SUMMARY OF THE INVENTION
[009] Before the present system is described, it is to be understood that this application is not limited to the particular machine, device or system, as there can be multiple possible embodiments that are not expressly illustrated in the present disclosures. It is also to be understood that the terminology used in the description is for the purpose of describing the particular versions or embodiments only, and is not intended to limit the scope of the present application. This summary is provided to introduce aspects related to a code modernization using a fusion of a hosted vector database with a foundational model, and the aspects are further elaborated below in the detailed description. This summary is not intended to identify essential features of the proposed subject matter nor is it intended for use in determining or limiting the scope of the proposed subject matter.
[0010] In an embodiment, the present invention discloses a code modernization system (100) comprising a data processing device operatively coupled with a one or more memory configured to store program instructions, when the program instructions executed by the processing device, direct the processing device to perform the steps of: capturing at-least a code and/or execution details of the code from a source application hosting node(s) (101); the source application hosting node(s) (101) could be a in premise hosted machine or a cloud based virtual machine. configuring a pre-trained functional model (104) based on code logic blocks from open-source repositories or proprietary written code logic blocks; transforming the code logic blocks into a customized code vector embedding configured to generate a plurality of high dimensional vectors; creating a vector database (103) from the plurality of high-dimensional vectors created in step above; coupling or combining the vector database with a Retrieval Augmented Generation (RAG) technique; passing the captured code and/or the execution details of the code as an input to the Retrieval Augmented Generation (RAG) technique to retrieve a set of relevant code from the vector database. passing the output of RAG technique as an input to the foundational model to generate modernised code/logic blocks.
[0011] In an embodiment, the RAG technique is configured to map the captured source code and execution details to the vector database (103).
[0012] In an embodiment, the vector database (103) is configured to store the vectors of the code and context-metadata in an n-dimensional graphical structure.
[0013] In an embodiment, the vector database (103) is configured to store and query high-dimensional vectors of the code and context metadata.
[0014] In an embodiment, the customized code vector embedding (103) comprises a transformer-based model configured to be trained on a massive dataset of the code logic blocks outputted from the foundational model (104).
[0015] In an embodiment, the customized code vector embedding (103) is configured to generate high-dimensional vectors that contain a semantic meaning and a context of the code.
[0016] In an embodiment, the vector database (103) is configured for reverse code search with vectors.
[0017] In an embodiment, the plurality of vectors stored in the vector database (103) is defined by vector indexes.
[0018] In an embodiment, the method for performing code modernization on a system (100), comprising of capturing at least a code and/or an execution detail of the code from a source application hosting node(s) (101); configuring a pre-trained functional model based on code logic blocks from an open-source repository (201); transforming the code logic blocks into a customized code vector embedding (102) configured to generate a plurality of high dimensional vectors; creating a vector database (103) from the plurality of high dimensional vectors; if an optional external or custom created foundational model (104) available: coupling or combining the vector database (103) with a Retrieval Augmented Generation (RAG) technique; passing the captured code and/or the execution details of the code as an input to the Retrieval Augmented Generation (RAG) technique to retrieve a set of relevant code from the vector database (103). The augmented prompt hits the foundational model (104) and gets the transformed code.
[0019] In yet another embodiment, the captured code and/or the execution details of the code is passed as an input to vector database alone, or, combination of vector database and foundational model, or, any other transformational system along with vector database or combination of vector database and foundational model.
[0020] In yet another embodiment, the captured code and/or the execution details of the code is passed as an input to a. vector database alone, or, combination of vector database and foundational model, or, any other transformational system along with vector database or combination of vector database and foundational model.
[0021] In yet another embodiment if a foundational model (104) is not available, pass the captured code and/or the execution details of the code directly as an input to the vector database (103), so that the vector database (103) matches the embeddings (102) and returns the transformed code or returns the content that helps to transform the code.

BRIEF DESCRIPTION OF DRAWING
[0022] The foregoing summary, as well as the following detailed description of embodiments, is better understood when read in conjunction with the appended drawings. For the purpose of illustrating the disclosure, there is shown in the present document example constructions of the disclosure, however, the disclosure is not limited to the specific methods and device disclosed in the document and the drawing. The detailed description is described with reference to the following accompanying figures.
[0023] Figure 1: illustrates the block diagram of the code modernization system;
[0024] Figure 2: illustrates an another embodiment of the code modernization system
[0025] Figure 3: illustrates the flow diagram of the code modernization system, in accordance with an embodiment of the present subject matter.
[0026] The figures depict various embodiments of the present disclosure for purposes of illustration only. One skilled in the art will readily recognize from the following discussion that alternative embodiments of the structures illustrated herein may be employed without departing from the principles of the disclosure described herein.
DETAILED DESCRIPTION OF THE INVENTION
[0027] Some embodiments of this disclosure, illustrating all its features, will now be discussed in detail. The words "comprising", “having”, and "including," and other forms thereof, are intended to be equivalent in meaning and be open-ended in that an item or items following any one of these words is not meant to be an exhaustive listing of such item or items, or meant to be limited to only the listed item or items. It must also be noted that, as used herein and in the appended claims, the singular forms "a," "an," and "the" include plural references unless the context clearly dictates otherwise. Although any devices and methods similar or equivalent to those described herein can be used in the practice or testing of embodiments of the present disclosure, the exemplary, devices and methods are now described. The disclosed embodiments are merely exemplary of the disclosure, which may be embodied in various forms.
[0028] Various modifications to the embodiment will be readily apparent to those skilled in the art and the generic principles herein may be applied to other embodiments. However, one of ordinary skill in the art will readily recognize that the present disclosure is not intended to be limited to the embodiments illustrated, but is to be accorded the widest scope consistent with the principles and features described herein.
[0029] In present invention, ‘code’ is referred as a single instruction or multiple instructions written in one or more programming language. ‘Code block’ is referred as a multiple code statements written in one or more programming language. ‘Code logic’ or ‘code-logic’ is referred as a one or multiple statements of code or one or multiple code block or one or multiple files in which code statements are written which may help perform some business purpose.
[0030] Following is a list of elements and reference numerals used to explain the embodiments of the present subject matter.
Reference Numeral Element Description
100 Code modernization system
101 Source Application hosting node(s)
102 Customized code vector embeddings
103 Vector database
104 Foundational Model
105 Target technology or target platform or target application
201 Open-source repositories
202 Customer source to target code blocks
203 Keywords, Vectors
[0031] In any business organization, applications or workloads that contain code logic, queries, instruction sets, executable statements, and scripts run on a connected cluster of nodes, which may be tens, hundreds, or even thousands or more in number. These nodes may run on environments like public clouds and private clouds, including on-premises data centres, or a combination of on premise data centres and the public cloud (called a hybrid system). The applications that run on these nodes may either run on an ad-hoc or scheduled basis which may have one-time execution or may be run on recurring schedules (hourly, daily, weekly, monthly). Every execution of the application generates execution log data, which captures execution runtime usage details, resources consumed, debug information, errors, or exceptions (if any). The application detail is the logic of the code (programming language code construct(s), queries, scripts, or similar instruction content). Execution detail includes execution log data, resource consumption details, debug, exception, or error information (if it exists). In the present invention, initially all application details (along with execution details) are captured either manually or one of the user or software process may upload the application details (along with execution details) to our proposed system. Further, a pre-trained foundational model based on code logic blocks from available open-source repositories is created.
[0032] In an embodiment, one of the available pre-trained foundational models, which is pre-trained on code logic as vector embeddings, may also be used. This is because functional models are pre-trained on a massive scale of code, and training a foundation model requires a significant amount of computing resources (GPUs, CPUs) as the models are trained on large datasets using deep learning algorithms.
[0033] The functional is trained on the code blocks. This means that in the functional model the code logic blocks or code entities snippets is first processed to determine an embedding of each code entity. The vector embeddings encode all types of code logic blocks into vectors that capture the meaning and context of the code logic blocks. Next, a vector database (103) is hosted on a single or multiple nodes of machines. The vector database (103) is a type of database that is specifically designed to store and query high-dimensional vectors. Vectors are mathematical representations of objects or data points in a multi-dimensional space, where each dimension corresponds to a specific feature or attribute. The vector databases are important because they hold vector embeddings and enable a set of capabilities, including indexing, distance metrics, and similarity search.
[0034] In other words, in the present invention, a customized embedding model is created, which is a transformer-based model trained on a massive dataset of code, or, in simple words, a function that takes code blocks and generates high-dimensional vectors that capture both the semantic meaning and the context of the code. Particularly, create vectors from that code. On the surface, a vector data type seems to be just an extension of an array that allows the array to be multidimensional as well as provide directionality when graphed. It is this directionality, within the n-dimensional space that allows neural networks to process functionality like nearest neighbour searches. For a given snippet of code, the code logic blocks to this function are passed, which creates vector embeddings of that code. Then major keywords, such as description, comment, labels, identifiers, or any other relevant information from code, which may be referred to as metadata, are abstracted. The vector embeddings created by this function are inserted into a vector database (103). The metadata is also inserted into the database. This way, the vector database (103) is populated. Once the data is embedded, a vector index on top of the relevant field inside their code snippets is defined. Then an approximate nearest neighbour may be used. This process of populating the vector database (103) is continuous.
[0035] In an embodiment, a reverse code search with vectors may also be performed, when the code logic blocks is given as input, reverse code search first can turns given code into a vector and then using vector search it can find the specific place in the n-dimensional graph that the code should be.
[0036] Further, in the present invention, all the captured application details along with execution details, rather than passing as an input directly to the functional models, are fed as an input to a Retrieval Augmented Generation (RAG). Retrieval Augmented Generation (RAG) is used to retrieve a set of relevant code from the vector database (103). Thus, in the present invention, there are two sources of modernization: the knowledge that foundational models store in their memory (parametric memory) and the knowledge stored in the vector database (103) from which RAG retrieves passages (non-parametric memory).
[0037] Figure 1 illustrates a code modernization system (100). The present invention discloses a code modernization system (100), wherein the system captures all application details (along with execution details) from the source code. The source application hosting node(s) (101) is configured on an in-premise hosted machine or a cloud-based virtual machine or a hybrid environment. The in-premise hosted machine is a private network of an organization and the cloud-based virtual machine is a virtual network in a remote data-centre. Further, the pre-trained functional model based on code logic blocks from open-source repositories (201) or proprietary written code logic blocks is configured in the system. The pre-trained functional model converts the code in to an information by a series of iterations. In the series of iterations, more and more code as a functional detail is given, until all system functionality is fully represented. Next, a customized code vector embedding function (102) generates a vector embedding for a code logic blocks outputted from the functional model. The vector embedding function is configured to generate a plurality of high dimensional vectors resulting further in to the vector database (103). The vector database (103) is a type of database that is specifically designed to store and query high-dimensional vectors. In present invention, the system may hosts a vector database (103) on a single or multiple nodes of machines. Particularly, the vectors are mathematical representations of objects or data points in a multi-dimensional space, where each dimension corresponds to a specific feature or attribute. Further, the system couples or combines the vector database (103) with the Retrieval Augmented Generation (RAG) technique, which passes the captured code and/or the execution details of the code as an input to the Retrieval Augmented Generation (RAG) technique to retrieve a set of relevant code from the vector database (103). The augmented output or a prompt from the RAG hits the foundational model (104) and gets the transformed or modernized code.
[0038] In an embodiment of the present invention, if the foundational model (104) is not available then the system passes the captured code and/or the execution details of the code as input to the vector database (103). The vector database (103) matches the embeddings and returns the transformed code or returns the content, which helps to transform the code logics.
[0039] In an embodiment, the vectors (203) stored in the vector database (103) is defined by vector indexes. Further, in the present invention, the code modernization system (100) may take legacy source code, convert it into vector embeddings (103), and use them to match custom modernized code logic in a vector database (103) by using a code foundational model.
[0040] Figure 2 illustrates an embodiment of the present invention. As illustrated in figure 2, the code modernization system (100) uses a combination of both the code vectorised foundational model (104) pre-trained on open-source code repositories/proprietary code feedings (201) and custom modernized code vectors from a vector database (103) to modernize applications from a source platform or programming language or version to a target platform (105) or a target app or language or version of a particular programming language. Further, the system creates prompts from source code blocks to search for an end-to-end differentiable model that combines a vector database (103) with a foundational model (104). Further, a customer source to target code blocks (202) as illustrated in said figure, represents the populating of the vector database with custom source code and with target source code so that it helps transforming the code. It do so by searching nearby vectors of the given code and in search results, it gets nearby target code.
[0041] Figure 3 illustrates a flow chart illustrating process 300 for modernizing code in accordance with embodiments of the present technology. In step 301, an application modernization system records or captured at-least a code and/or execution details of the code from a source application hosting node(s) (101), the system records captured at-least a code and/or execution details of the code to identify or store what type of application is required from a functionality and behavior standpoint. Further, the application modernization system generates or is configured with the functional model in step 302. The functional model is a pre-trained functional model based on code logic blocks from open-source repositories (201) or proprietary written code logic blocks. The pre-trained functional model based on code logic blocks may be used to understand the code behavior. The pre-trained functional model based on code logic blocks results in the vector database (103) of the code logic blocks by transforming the code logic blocks outputted from the pre-trained functional model into a customized code vector embedding configured to generate a plurality of high-dimensional vectors and then creating a vector database (103) from the plurality of high-dimensional vectors in step 303. This process is also called populating the vector database (103). In step 304, the vector database (103) is then combined with a Retrieval Augmented Generation (RAG) technique and in step 305, the captured code and/or the execution details of the code is then passed as an input to the Retrieval Augmented Generation (RAG) to retrieve a set of relevant code from the vector database (103). The augmented output from the RAG hits the foundational model and gets the transformed code. Further, in step 306, if foundational model is not available, the captured code and/or the execution details of the code is passed as an input to the vector database (103). The vector database (103) matches the embeddings and returns the transformed code or returns the content that helps to transforms the code.

[0042] The code modernization system of the present invention helps organizations and software developer or another user to upgrade their existing business logic from one technology to latest technology with Automation. Automation brings the benefits of being less error prone, faster and less costly. Organization can use this invention to perform fully automated or partly automated use case lift & shift, refactoring, rearchitecting in less time, with less engineering human resource. Organizations and its software developer can understand design changes from one version to the next or transform the source technology to the target technology with simple evaluation of correctness, robustness, and security, in addition to other program considerations and factor.
Equivalents
[0043] With respect to the use of substantially any plural and/or singular terms herein, those having skill in the art can translate from the plural to the singular and/or from the singular to the plural as is appropriate to the context and/or application. The various singular/plural permutations may be expressly set forth herein for the sake of clarity.
[0044] It will be understood by those within the art that, in general, terms used herein, and especially in the appended claims (e.g., bodies of the appended claims) are generally intended as "open" terms (e.g., the term "including" should be interpreted as "including but not limited to," the term "having" should be interpreted as "having at least," the term "includes" should be interpreted as "includes but is not limited to," etc.). It will be further understood by those within the art that if a specific number of an introduced claim recitation is intended, such an intent will be explicitly recited in the claim, and in the absence of such recitation no such intent is present.
[0045] Although implementations for the code modernization system (100) have been described in language specific to structural features and/or methods, it is to be understood that the appended claims are not necessarily limited to the specific features described. Rather, the specific features are disclosed as examples of implementation for the code modernization system (100).
, Claims:
1. A system (100) for code modernization comprising
a data processing device operatively coupled with a one or more memory configured to store program instructions, wherein when the program instructions executed by the processing device, direct the processing device to perform the steps of:
capturing at-least a code and/or execution details of the code from a source application hosting node(s) (101); the source application hosting node(s) (101) could be a in premise hosted machine or a cloud based virtual machine or hybrid.
configuring a pre-trained functional model (104) based on code logic blocks from open-source repositories (201) or proprietary written code logic blocks;
transforming the code logic blocks into a customized code vector embedding configured to generate a plurality of high dimensional vectors;
creating a vector database (103) from the plurality of high-dimensional vectors created in step above;
coupling or combining the vector database with a Retrieval Augmented Generation (RAG) technique;
passing the captured code and/or the execution details of the code as an input to the Retrieval Augmented Generation (RAG) technique to retrieve a set of relevant code from the vector database.
passing the output of RAG technique as an input to the foundational model to generate modernised code/logic blocks.

2. The system (100) for code modernization as claimed in claim 1, wherein the RAG is configured to map the captured source code and execution details to the vector database.

3. The system (100) for code modernization as claimed in claim 1, wherein the vector database is configured to store the vectors of the code and context metadata in an n-dimensional graphical structure.

4. The system (100) for code modernization as claimed in claim 1, wherein the vector database is configured to store and query high-dimensional vectors of the code context metadata.

5. The system (100) for code modernization as claimed in claim 1, wherein the customized code vector embedding comprises a transformer-based model configured to be trained on a massive dataset of the code logic blocks outputted from the foundational model.

6. The system (100) for code modernization as claimed in claim 1, wherein the customized code vector embedding is configured to generate high-dimensional vectors that contain a semantic meaning and a context of the code.

7. The system (100) for code modernization as claimed in claim 1, wherein the vector database is configured for reverse code search with vectors.

8. The system (100) for code modernization as claimed in claim 1, wherein the plurality of vectors stored in the vector database are defined by vector indexes.

9. The system (100) for code modernization as claimed in claim 1, wherein the captured code and/or the execution details of the code is passed as an input directly to the vector database, if foundational model is not available, so that the vector database matches the embeddings and returns the transformed code or returns a content that helps to transforms the code.

10. The system (100) for code modernization as claimed in claim 1, wherein the captured code and/or the execution details of the code is passed as an input to

a. vector database alone, or,
b. combination of vector database and foundational model, or,
c. any other transformational system along with vector database or combination of vector database and foundational model.

11. A method for performing code modernization on a system (100), comprising:
capturing at-least a code block/one or multiple statements and/or an execution detail of the code from a source application hosting node(s) (101);
configuring a pre-trained functional model (104) based on code logic blocks from an open source repositories;
transforming the code logic blocks into a customized code vector embedding configured to generate plurality of high dimensional vectors;
creating a vector database (103) from the plurality of high dimensional vectors;
coupling or combining the vector database with a Retrieval Augmented Generation (RAG) technique;
passing the captured code and/or the execution details of the code as an input to the Retrieval Augmented Generation (RAG) technique to retrieve a set of relevant code from the vector database;
passing the output of RAG technique as an input to the foundational model to generate modernised code/logic blocks.