Patent Application
20250181336
The present disclosure relates generally to computer systems, and in particular, to systems and method for enabling software code to support different languages.
Software applications comprise executable code written by software developers.
Typically, the developers write the texts that are displayed by their code in a language that is either native to the developer or the language of the target market for the software application. Accordingly, much of these texts may be written in one language that may not be suitable for deployment globally. Developing code for worldwide use can be time consuming and expensive.
The present disclosure addresses these and other challenges and is directed to techniques for generating software code in different languages.
Described herein are techniques for enabling software code for different languages. In the following description, for purposes of explanation, numerous examples and specific details are set forth in order to provide a thorough understanding of some embodiments. Various embodiments as defined by the claims may include some or all of the features in these examples alone or in combination with other features described below and may further include modifications and equivalents of the features and concepts described herein.
Features and advantages of the present disclosure include techniques for using generative artificial intelligence (AI) (e.g., large language models) to generate prompts that instruct the AI models in a way that ensures their code output is translatable. Embodiments may be used in the form of prompt embedding, adding prompt parts to a pre-existing prompt created by a software developer, in order to ensure new AI generated code is translatable, or it can also be used standalone to process existing code in order to make it translatable, for example. In some embodiments, the present disclosure includes a software system or methods that may be used as a plugin that can be installed on a development tool or in a build infrastructure. A development tool refers to a tool used to create software, known as IDE (Integrated Development Environment). Through this plugin, the user can make all necessary configurations regarding how the plugin should behave and respond. A build infrastructure is a set of tools working together to bring source code to a deliverable state. Usually this includes at least a source code management software system (like Git or SVN) and a processing tool commonly called ‘pipeline’, for example.
In some embodiments, the present disclosure includes software services (tools or components) to optimize the software end-to-end development process related to language expertise, which will help developers and development teams to design solutions for use in different languages. For example, a large language model (LLM) may be trained on top of existing generative AI solutions focused on translatability and code adaptations. In some embodiments, the system includes a training layer focused on identifying and refactoring code for translatability. In some embodiments, the system is configured to detect language translation problems when receiving or generating a generative LLM prompt to generate source code. For example, a generative AI may receive requests to store UI text strings in the code in properties files or an ABAP backend in order to ensure the translatability. Further, the system may include connections to additional sources like a “Source Quality” system, which performs quality checks for English source language texts (e.g., as part of continuous software build process), a machine translation software system, and different LLMs to verify the quality of generated UIs texts, translate them, and check the quality of the resulting translation. For example, the system may verify inputs and/or outputs of an LLM using source quality API (for input) or machine translation API (for output) to ensure consistent terminology usage. In some embodiments, a generative LLM may learn iteratively with feedback from developers, for example. Accordingly, project configurations related to translatability may be shared across developers and teams to improve translatability of software products, for example. As mentioned above, in some embodiments, the present disclosure may include a plugin for software development tools which offers a large scale of services related to language expertise. From warnings to the developer when hardcoded texts are detected (“Did you think about other countries/languages?”) to automatically embedded prompt engineering in order to ensure that the AI-generated code is translatable.
In some embodiments, system 100 may generate code in a plurality of languages. A prompt 110 may specify source code. Prompt 110 includes an instruction 111 to extract translatable code elements from the source code. In some embodiments, prompt 110 is generated by a user. In other embodiments, a user enters a first prompt to generate source code and the prompt from the user is automatically modified to include the instruction to extract translatable code elements from the source code. In some embodiments, prompt 110 comprises an instruction to generate source code. In other embodiments, prompt 110 comprises source code to be processed by the LLM to extract code elements to be translated as described herein. In some embodiments, the prompt specifies a parts of the source code that includes text values to be extracted. Additionally, instruction 111 may specify a file 112 to store extracted code elements.
Prompt 110 may be entered into LLM 101. LLM 101 may process source code and extract code elements from the source code. As indicated above, in some embodiments LLM 110 may produce code elements from existing source code. In other embodiments, LLM 110 may generate source code and produce code elements to be translated. Code elements are stored in a code elements file 112. In various embodiments, code elements comprise hard coded text strings (e.g., “sting”) output to a user (e.g., as messages in a UI) in the source code. Such code elements may be part of a print, standard I/O, display, message, or similar code construct comprising a string of characters printed to an output device, for example.
In this embodiment, the code elements received from the large language model are sent to multi-language software system 102. Multi-language software system 102 receives the code elements in a first language and converts the code elements into a second plurality of code elements in a different language. In some embodiments, the second plurality of code elements comprise the hard coded text strings translated into a different language. The second plurality of code elements may be stored in an output code elements file 113, for example. Additionally, the system may replace the plurality of code elements in the source code with the second plurality of code elements in the different language to produce source code 114. In some embodiments, LLM 101 is trained to identify first hard coded text strings and replace the first hard coded text strings with links to one or more external files 113 comprising the second hard coded text strings in a different language. Accordingly, output text strings in one language in initial source code may be replaced with links to output text strings in a file so that the language of the output text strings may be changed by changing an associated language text file rather than the source code.
In various embodiment, the present disclosure may include techniques for translating software code into different languages. In some embodiments, generative AI may be used to generate code (e.g., boilerplate code, which does not include business rules or is complex in nature but requires time and effort to be created). Embodiments may use such an approach to generating new code for new applications that are translatable and translated as generated, transform current applications into a new coding/technology stack, provide customers with the possibility to modify default usage scenarios in an easy and quick way, and/or make non-translatable existing applications translatable by running them through LLMs and other foundation models. For example, many software applications are built with the “English (EN) First” approach. Embodiments of the present disclosure may use language software systems to provide code for non-EN speaking countries from the beginning. Accordingly, the present disclosure includes tools to optimize the essential parts of the end-to-end development process related to language expertise which may help developers and development teams to design solutions which can be used in different languages. For example, as mentioned above, embodiments may support “Translation aware” prompt engineering (e.g., ensuring the translatability) at the UX design and then development stage (e.g., clear requests to have the UI texts and the messages stored in properties files or an ABAP backend in order to ensure the translatability), connection to additional sources like SAP® Source Quality Control (SQC), machine translation (MT) and different LLMs to verify the quality of generated UIs texts, translate and check the quality of the resulting translation (e.g., using an SQC API (for input) or MT API (output) and verify the input/output for example for consistent terminology usage), enable an obligatory human-review step by native speakers with In-Context Editing and saving the changes in a way that permits learning from them (e.g., using a cloud translator for checking UIs and providing missing translations based on translation memories and MT), and/or adaptions (or enhancements/customization) of the UI texts on the customer side (e.g., providing points 1-3 to customers as a commercial offering), for example. Accordingly, embodiments of the present disclosure include, for example, an IDE Plugin which offers a full scale of services from warnings (“Did you think about other countries/languages?”) to automatically embedded prompt engineering in order to ensure that AI-generated code is translatable. The plugin can provide an underlying connection to one or more language repositories and MT software systems, among other language services.
In a first example scenario, a developer is requesting the plugin to generate new code. The developer creates the following prompt:
“Please create a simple Sales Order Fiori app containing material number, name of article, price and the amount.”
The plugin calls the underlying generative AI model with this prompt as requested by the developer, but this prompt would render a code that contains hard coded strings and is therefore not translatable. Therefore, the present improved plugin can use a ‘prompt embedding’ technique to enhance the developer's prompt in order to ensure the resulting code is translatable. Gen AI integration model in
“The UI text strings should be in properties file.”
If the developer would so choose, they could also instruct the plugin via settings that there is need to provide automatic translation for the generated texts. In this case, the plugin can also modify the prompt to ask the Gen AI model to provide translation files in specific languages as follows:
“A translation of the texts into German should be provided.”
The resulting prompt may then be as follows:
“Please create a simple Sales Order Fiori app containing material number, name of article, price and the amount. The UI text strings should be in properties file. A translation of the texts into German should be provided.”
As indicated above, the AI model/LLM may be trained to generate code for a particular application (e.g., Fiori). The LLM Output is as follows:
For the translations. you would have a ‘i18n.properties’ file for English:
As yet another example, a developer may request the plugin to refactor existing code to make it translatable. This may be the case with legacy code or human generated code where language features are not taken into account from the beginning of development.
In this case, the developer may not need to provide a prompt. Rather, code translatability is generated by the plugin based on configurations done by the developer such as programming language of the source code, target format of the internationalized files, location of these files, languages into which extracted texts should be translated etc.
When the developer sends the command to refactor, the plugin will send the code along with an automatically generated prompt. If the desired format is a properties files, for instance, the generated prompt may be as follows:
[NEW PROMPT] Please extract the translation relevant texts from the code below into a properties file that can be used in translation. Replace the texts by their corresponding keys in the code and return the whole code. Give me just the result, not the steps or explanations.
If translations were requested, this request can also be embedded to the default prompt as follows:
[NEW PROMPT SEGMENT] Generate the corresponding translation files for the properties file into German.
An example of the pre-existing input source code is as follows:
An example of the LLM output code is as follows:
An example of the LLM output properties file is as follows:
In some systems, computer system 510 may be coupled via bus 505 to a display 512 for displaying information to a computer user. An input device 511 such as a keyboard, touchscreen, and/or mouse is coupled to bus 505 for communicating information and command selections from the user to processor 501. The combination of these components allows the user to communicate with the system. In some systems, bus 505 represents multiple specialized buses for coupling various components of the computer together, for example.
Computer system 510 also includes a network interface 504 coupled with bus 505. Network interface 504 may provide two-way data communication between computer system 510 and a local network 520. Network 520 may represent one or multiple networking technologies, such as Ethernet, local wireless networks (e.g., WiFi), or cellular networks, for example. The network interface 504 may be a wireless or wired connection, for example. Computer system 510 can send and receive information through the network interface 504 across a wired or wireless local area network, an Intranet, or a cellular network to the Internet 530, for example. In some embodiments, a frontend (e.g., a browser), for example, may access data and features on backend software systems that may reside on multiple different hardware servers on-prem 531 or across the network 530 (e.g., an Extranet or the Internet) on servers 532-534. One or more of servers 532-534 may also reside in a cloud computing environment, for example.
Each of the following non-limiting features in the following examples may stand on its own or may be combined in various permutations or combinations with one or more of the other features in the examples below. In various embodiments, the present disclosure may be implemented as a system, method, or computer readable medium.
Embodiments of the present disclosure may include systems, methods, or computer readable media. In one embodiment, the present disclosure includes computer system comprising: at least one processor and at least one non-transitory computer readable medium (e.g., memory) storing computer executable instructions that, when executed by the at least one processor, cause the computer system to perform a method as described herein and in the following examples. In another embodiment, the present disclosure includes a non-transitory computer-readable medium storing computer-executable instructions that, when executed by at least one processor, perform a method as described herein and in the following examples.
In some embodiments, the present disclosure includes a method of generating code in a plurality of languages comprising: entering a prompt specifying source code and an instruction to extract translatable code elements from the source code into a large language model; receiving, from the large language model, a plurality of code elements extracted from the source code; sending the plurality of code elements to a multi-language software system; receiving, from the multi-language software system, the plurality of code elements converted to a second plurality of code elements in a different language; and replacing the plurality of code elements in the source code with the second plurality of code elements.
In one embodiment, the large language model is a generative large language model.
In one embodiment, the plurality of code elements comprise first hard coded text strings output to a user in the source code, wherein the second plurality of code elements comprise the second hard coded text strings output to the user corresponding to the first hard coded text strings translated into a different language, and wherein the large language model is trained to identify first hard coded text strings and replace the first hard coded text strings with links to one or more external files comprising the second hard coded text strings.
In one embodiment, the prompt is generated by a user.
In one embodiment, the prompt is a second prompt and the specified source code is source code to be generated, the method further comprising receiving a first prompt from a user to generate the source code and automatically modifying the second prompt to include the instruction to extract translatable code elements from the source code.
In one embodiment, the multi-language software system is a language translation software system that translates the plurality of code elements in a first language to the second plurality of code elements in the different language.
In one embodiment, further comprising: reviewing, by a user, the second plurality of code elements; and entering the second plurality of code elements into a language verification software system to verify the second plurality of code elements.
In one embodiment, the plurality of code elements comprise hard coded text strings in the source code, wherein the second plurality of code elements comprise the hard coded text strings translated into a different language.
In one embodiment, the entering, receiving the plurality of code elements, sending, receiving the second plurality of code elements, and replacement steps are incorporated into an integrated development environment as a translation plug-in.
In one embodiment, the entering, receiving the plurality of code elements, sending, receiving the second plurality of code elements, and replacement steps are incorporated into a build environment as a translation plug-in.
In one embodiment, the prompt specifying source code comprises an instruction to generate source code.
In one embodiment, the prompt specifying source code comprises the source code.
In one embodiment, the instruction to extract translatable code elements from the source code specifies a file to store the plurality of code elements.
In one embodiment, the prompt specifies a data structure of the source code and text values to be extracted.
The above description illustrates various embodiments along with examples of how aspects of some embodiments may be implemented. The above examples and embodiments should not be deemed to be the only embodiments, and are presented to illustrate the flexibility and advantages of some embodiments as defined by the following claims. Based on the above disclosure and the following claims, other arrangements, embodiments, implementations, and equivalents may be employed without departing from the scope hereof as defined by the claims.
