system

Abstract

Provide a system. 【Solution means】 Means for receiving legacy source code and analyzing its structure and dependencies, Means for generating a cloud-native architecture from the analyzed legacy source code, Means for converting the source code of the legacy system into a new programming language based on the generated cloud-native design, Means for creating and implementing automatic verification cases for the new source code after conversion, Means for analyzing business rules in the legacy source code and applying those rules to the new source code, Means for scanning the source code with a mobile terminal or wireless communication device and visualizing the analyzed results, Means for monitoring in real time the conversion status from the legacy system using an external computing environment and presenting progress and issues, A system including the above.

Description

Technical Field

[0001] The technology of the present disclosure relates to a system.

Background Art

[0002] Patent Document 1 discloses a persona chatbot control method performed by at least one processor, including steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to an explanation of a chatbot character, encoding the prompt, and inputting the encoded prompt into a language model to generate a chatbot utterance in response to the user utterance.

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] The migration of legacy systems in conventional information systems involves high costs, long time, and high risks, and requires engineers with specialized knowledge. Therefore, the limitations of business flexibility faced by many enterprises and the increase in system maintenance costs have become problems. Also, due to old - fashioned technologies, there is also a problem that it is difficult to respond to new business environments and security.

Means for Solving the Problems

[0005] This invention employs generative AI technology to automatically analyze the source code of legacy systems, understand their structure and dependencies, and redesign them for a cloud-native architecture. It also provides a means to automate the conversion of code to a new programming language based on the analyzed data. Furthermore, it ensures quality assurance by automatically generating and executing test cases for the new source code, and solves the aforementioned problems by building a system that analyzes and applies business logic using natural language processing technology and proposes optimizations.

[0006] "Legacy source code" refers to existing program code written in older programming languages ​​that still runs but does not conform to modern technological standards.

[0007] "Cloud-native architecture" is a form of distributed system design that is optimized for online server environments and is a design methodology that offers scalability and flexibility.

[0008] "Generative AI technology" is a technology that uses artificial intelligence to automatically generate software or convert code.

[0009] "Natural language processing technology" is a technology that enables computers to understand and process human language.

[0010] "Business logic" in a software system refers to a set of actions and calculations that fulfill specific business requirements.

[0011] A "dependency" refers to a relationship in which one software component depends on another, and it is required that these dependencies maintain their consistency when they are modified.

[0012] "Deployable" means that specific software is in a state where it can run properly in the configured environment. [Brief explanation of the drawing]

[0013] [Figure 1] This is a conceptual diagram showing an example of the configuration of a data processing system according to the first embodiment. [Figure 2] This is a conceptual diagram showing an example of the essential functions of a data processing device and a smart device according to the first embodiment. [Figure 3] This is a conceptual diagram showing an example of the configuration of a data processing system according to the second embodiment. [Figure 4] This is a conceptual diagram showing an example of the main functions of a data processing device and smart glasses according to the second embodiment. [Figure 5] This is a conceptual diagram showing an example of the configuration of a data processing system according to the third embodiment. [Figure 6] This is a conceptual diagram showing an example of the main functions of a data processing device and a headset-type terminal according to the third embodiment. [Figure 7] This is a conceptual diagram showing an example of the configuration of a data processing system according to the fourth embodiment. [Figure 8] This is a conceptual diagram showing an example of the main functions of a data processing device and a robot according to the fourth embodiment. [Figure 9] This shows an emotion map where multiple emotions are mapped. [Figure 10] This shows an emotion map where multiple emotions are mapped. [Figure 11] This is a sequence diagram showing the processing flow of the data processing system in Example 1. [Figure 12] This is a sequence diagram showing the processing flow of the data processing system in Application Example 1. [Figure 13] This is a sequence diagram showing the processing flow of the data processing system in Example 2, which incorporates an emotion engine. [Figure 14] This is a sequence diagram showing the processing flow of the data processing system in Application Example 2, which combines an emotion engine. [Modes for carrying out the invention]

[0014] An example of an embodiment of the system according to the technology of the present disclosure will be described below with reference to the accompanying drawings.

[0015] First, the terms used in the following description will be explained.

[0016] In the following embodiments, a labeled processor (hereinafter simply referred to as "processor") may be a single arithmetic unit or a combination of multiple arithmetic units. Also, the processor may be a single type of arithmetic unit or a combination of multiple types of arithmetic units. Examples of arithmetic units include a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-Purpose computing on Graphics Processing Units), an APU (Accelerated Processing Unit), and the like.

[0017] In the following embodiments, a labeled RAM (Random Access Memory) is a memory in which information is temporarily stored and is used as a work memory by the processor.

[0018] In the following embodiments, a labeled storage is one or more non-volatile storage devices that store various programs and various parameters, etc. Examples of non-volatile storage devices include flash memory (SSD (Solid State Drive)), magnetic disks (e.g., hard disks), or magnetic tapes, etc.

[0019] In the following embodiments, the signed communication interface (I / F) is an interface that includes a communication processor and an antenna, etc. The communication interface manages communication between multiple computers. Examples of communication standards applicable to the communication interface include wireless communication standards such as 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), or Bluetooth (registered trademark).

[0020] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." That is, "A and / or B" means that it may be A alone, or B alone, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" applies when expressing three or more things linked by "and / or."

[0021] [First Embodiment]

[0022] Figure 1 shows an example of the configuration of the data processing system 10 according to the first embodiment.

[0023] As shown in Figure 1, the data processing system 10 includes a data processing device 12 and a smart device 14. An example of the data processing device 12 is a server.

[0024] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0025] The smart device 14 comprises a computer 36, a reception device 38, an output device 40, a camera 42, and a communication interface 44. The computer 36 comprises a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The reception device 38, output device 40, and camera 42 are also connected to the bus 52.

[0026] The reception device 38 is equipped with a touch panel 38A and a microphone 38B, etc., and receives user input. The touch panel 38A receives user input by detecting contact with an object (e.g., a pen or finger). The microphone 38B receives user input by detecting the user's voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the data indicating the user input.

[0027] The output device 40 includes a display 40A and a speaker 40B, and presents data to the user 20 by outputting the data in a form perceptible to the user 20 (e.g., audio and / or text). The display 40A displays visible information such as text and images according to instructions from the processor 46. The speaker 40B outputs audio according to instructions from the processor 46. The camera 42 is a small digital camera equipped with an optical system such as a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0028] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various types of information between processor 46 and processor 28 via network 54.

[0029] Figure 2 shows an example of the main functions of the data processing device 12 and the smart device 14.

[0030] As shown in Figure 2, in the data processing device 12, a specific processing is performed by the processor 28. A specific processing program 56 is stored in the storage 32. The specific processing program 56 is an example of a "program" related to the technology of this disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 according to the specific processing program 56 executed on the RAM 30.

[0031] The storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0032] In the smart device 14, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The reception output program 60 is used in conjunction with a specific processing program 56 by the data processing system 10. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0033] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the smart device 14 as the "terminal".

[0034] The system according to the present invention aims to efficiently migrate a company's legacy systems to a modern cloud-native environment. When implementing this system, each component works in cooperation with each other as follows, achieving a seamless migration process as a whole.

[0035] First, the user inputs the source code of the legacy system to be migrated into the system via a terminal. This source code is written in older languages ​​and frameworks. When the server receives this code, it first performs syntax analysis to understand the code's structure and dependencies. This analysis helps to understand the overall picture of the source code and identify inefficiencies and risks associated with the migration.

[0036] Based on the analysis results, the server utilizes generative AI technology to generate a cloud-native architecture design. The generated design is based on a microservices structure, achieving flexible scalability. At this stage, it is defined which parts will be adapted to the new environment and how.

[0037] As a concrete example, consider an old COBOL-based inventory management system. The business logic of this system is to automatically replenish inventory when it falls below a certain level. The server analyzes this logic and generates a design so that the same functionality can be applied in a new cloud environment.

[0038] Next, the server uses a conversion mechanism to convert the original COBOL code into a new programming language, such as Java® or Python. This conversion not only replaces the language of the code but also optimizes the entire program to be runnable on the cloud.

[0039] Since the converted code cannot be tested directly, the server automatically generates and executes test cases. The tests mainly consist of unit tests and integration tests to verify that the entire system functions correctly. This automated testing method ensures high accuracy in the quality of the converted code and minimizes operational problems after migration.

[0040] Furthermore, the server utilizes natural language processing technology to appropriately analyze and apply the business logic within the legacy source code, ensuring that the new system meets the original business requirements. Optimization of the business logic is also performed as needed.

[0041] Through this series of processes, users can achieve advanced system migration with minimal need for specialized knowledge or technical support. Therefore, the embodiment of the present invention achieves reduced migration costs, mitigated migration risks, and improved operational flexibility.

[0042] The following describes the processing flow.

[0043] Step 1:

[0044] The user uploads the legacy source code to be migrated to the server via their terminal. The server saves the received code to storage and prepares it for analysis.

[0045] Step 2:

[0046] The server begins syntax analysis of the uploaded source code. This analysis helps to understand the overall structure of the code, functions, variables, and dependencies, and generates a dependency map.

[0047] Step 3:

[0048] The server uses generative AI technology to generate cloud-native architecture designs based on analysis results. For example, it designs microservice models and API interfaces for service partitioning.

[0049] Step 4:

[0050] The server translates the legacy source code into a new programming language of its choice, according to the generated design. The translation ensures that each function and data structure functions correctly in the new language.

[0051] Step 5:

[0052] The server uses AI to generate automated test cases for the newly converted code and runs these tests. These tests include unit tests and integration tests to verify the quality and accuracy of the code.

[0053] Step 6:

[0054] The server uses natural language processing to extract the business logic contained in the original code and verify that it is correctly reflected in the new code. If necessary, it suggests optimizations to the business logic.

[0055] Step 7:

[0056] As a final check, the server verifies that the new system can be deployed to the cloud environment. This includes checking resource settings and security policies.

[0057] Step 8:

[0058] The server sends a notification to the user that the migration is complete and finally verifies that the migrated system meets the required performance and functional requirements.

[0059] (Example 1)

[0060] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0061] Many corporate information processing environments still operate legacy systems built on outdated technological foundations, often unable to adapt to new technologies. This makes migrating to the latest distributed processing infrastructure difficult, resulting in increasing operational costs and technical debt. Furthermore, maintaining and optimizing business rules during the conversion process is crucial, necessitating complete automation.

[0062] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0063] In this invention, the server includes means for receiving legacy information and analyzing its structure and dependencies, means for generating a distributed processing platform design from the analyzed legacy information, and means for converting the legacy information into a new programming syntax based on the generated distributed processing platform design. This enables a smooth transition of legacy systems to the latest technological environment and reduces operational costs.

[0064] "Legacy information" refers to existing information systems built on older technological foundations that are difficult to adapt to the latest technological environment.

[0065] "Structure" refers to the internal organization of information or a system, as well as the relationships between its elements.

[0066] "Dependency" refers to a state in which elements of different systems or structures are mutually dependent on each other.

[0067] "Means of analysis" refers to techniques and methods for breaking down information and understanding its structure and characteristics.

[0068] A "distributed processing infrastructure" refers to a structure or technology that distributes information processing across multiple independent computers.

[0069] "Means of generating a design" refers to methods and techniques for creating a system design or plan based on a specific purpose.

[0070] "Programming syntax" refers to the format and rules of code used to specify behavior in a particular programming language.

[0071] "Evaluation criteria" refers to standards or rules established to verify the operation and performance of new information or systems.

[0072] "Business rules" refer to regulations that define the conditions and methods for business processes executed within an organization or system.

[0073] "Natural language processing technology" refers to the techniques and methods used to understand and process human language using computers.

[0074] This invention provides a system for migrating an enterprise's outdated information processing system to a state-of-the-art distributed processing infrastructure environment. Specific embodiments thereof are described below.

[0075] Users input foundational information from the company's existing information systems into the server via a terminal. This foundational information is written using outdated programming techniques and frameworks.

[0076] The server uses a syntax analysis tool (e.g., ANTLR) to parse the input information. This clarifies the structure and dependencies of the information, identifying inefficiencies and risks associated with the migration.

[0077] Based on the analysis results, the server utilizes a generated AI model (e.g., OpenAI's GPT) to create a new distributed processing platform design. This design is particularly adapted to cloud services (e.g., AWS and GCP) and is based on a microservices architecture.

[0078] Next, the server uses a conversion engine to convert the original information into a new programming syntax, such as Java or Python. This conversion not only replaces the syntax but also optimizes it to suit the new platform.

[0079] Subsequently, to verify the code's operation, the server automatically generates and executes evaluation criteria. These tests primarily consist of unit tests and integration tests, confirming the proper functioning of the entire system.

[0080] Furthermore, the server uses natural language processing technology to appropriately analyze and apply the business rules of the underlying information, and verifies that the new information meets the original business requirements. If necessary, it also optimizes the business rules.

[0081] As a concrete example, consider a COBOL-based inventory management system. One of the system's operational rules is to automatically replenish inventory when it falls below a certain level. The server analyzes this rule and configures the system to function similarly on the new distributed infrastructure.

[0082] For example, enter the following prompt:

[0083] "Analyze this COBOL-based inventory management system and generate Java code adapted for a cloud-native environment."

[0084] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0085] Step 1:

[0086] The user inputs foundational information from the legacy system into the server via a terminal. This information is written in an older programming language (e.g., COBOL). This input information forms the basis for processing.

[0087] Step 2:

[0088] The server performs syntax analysis based on the input information. At this stage, a syntax analysis tool (e.g., ANTLR) is used to analyze the code structure and dependencies. The output is the internal structure of the code and a dependency map.

[0089] Step 3:

[0090] Based on the analysis results, the server generates a distributed processing infrastructure design using a generated AI model. It receives the analysis results as input and outputs a design document for a microservice architecture suitable for a cloud environment.

[0091] Step 4:

[0092] The server runs a conversion engine that translates the original programming language into a new language (e.g., Java, Python). This process optimizes the code based on the design document and outputs the converted program.

[0093] Step 5:

[0094] The converted code enters a testing stage to verify that it works correctly. The server automatically generates unit and integration tests and runs them using testing tools. Based on the test results, the code is evaluated to see if it functions properly.

[0095] Step 6:

[0096] Furthermore, the server uses natural language processing technology to analyze the business rules contained in the underlying information. The acquired business rules are applied to the converted information to verify whether the required business functions are maintained. The output is the result of the business rule compliance verification.

[0097] (Application Example 1)

[0098] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0099] In recent years, legacy systems used within companies have become unable to keep up with the rapidly changing business environment, resulting in a significant burden for their maintenance and operation. Furthermore, migrating to a cloud-native environment requires technical knowledge and effort, posing a major obstacle, especially for small and medium-sized enterprises. Moreover, managing the progress of the migration process and detecting problems early is difficult, leading to project delays and increased costs. Therefore, a system capable of efficient and real-time migration is necessary.

[0100] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0101] In this invention, the server includes means for receiving legacy source code and analyzing its structure and dependencies, means for generating a cloud-native architecture from the analyzed legacy source code, and means for scanning the source code using a mobile terminal or wireless communication device and visualizing the analysis results. This enables users to smoothly proceed with the migration process of legacy systems to the cloud, and to understand the situation and solve problems in real time.

[0102] "Legacy source code" refers to older program code that a company or organization has used for a long period of time, and is usually written using older programming languages ​​or technologies.

[0103] "Structural and dependency analysis" is the process of identifying and understanding the internal structure of program code and its interdependencies with other components.

[0104] A "cloud-native architecture" is a design optimized for cloud environments, offering flexibility and scalability, and is often based on a microservices architecture.

[0105] "Programming language conversion" is the process of translating specific program code into a different programming language so that it can run in a new environment.

[0106] An "automatic verification case" is a test scenario that is automatically generated to verify the accuracy and functionality of the converted program code.

[0107] "Business rules" are the business logic and rules defined within a legacy system that need to be reproduced in the new system.

[0108] "Mobile devices or wireless communication devices" refer to electronic devices that use wireless communication technology to process information, including smartphones and smart glasses.

[0109] "Visualization of analysis results" is the process of displaying the analyzed data and progress in a format that is easy for users to understand.

[0110] An "external computing environment" refers to an environment used for performing computational processing using cloud services or remote servers.

[0111] The system for realizing this invention provides a series of processes for efficiently migrating to the cloud. The server receives legacy source code scanned by a user's mobile device. This device is a common portable information processing device, such as a smartphone or smart glasses.

[0112] First, the server uses a generative AI model to analyze the structure and dependencies of the legacy source code in detail. Based on the data obtained from this analysis, the server designs an optimal cloud-native architecture. This architecture is flexible and scalable, and is primarily based on a microservices architecture.

[0113] Next, the server translates the legacy source code into a new programming language based on the analysis results. This translation is not a direct substitution of code between languages, but includes optimizations suitable for the cloud environment. The server efficiently performs this process by utilizing external computing environments, such as Google Cloud Platform or Amazon Web Services.

[0114] The newly converted source code is verified for functionality and accuracy using automatically generated validation cases. This ensures high quality and confirms that the migrated system operates correctly. Users can visualize and understand this progress and any remaining issues via their mobile devices.

[0115] As a concrete example, users can use smart glasses during meetings to monitor the status of the cloud migration process and participate in real-time discussions. An example of a prompt is, "Analyze the code of this COBOL-based inventory management system and generate a cloud-native design based on a microservices architecture." This prompt allows the generating AI model to support the cloud migration quickly and effectively.

[0116] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0117] Step 1:

[0118] The user scans legacy source code using a terminal and sends it to the server. The input is a code image captured by the terminal's camera. The terminal converts the image to text format and sends that text data to the server.

[0119] Step 2:

[0120] The server uses a generative AI model to analyze the structure and dependencies of the received text data. The input is the scanned source code text data, and the output is the code's structural analysis data. The server identifies dependencies and analyzes the data flow and constraints within the program.

[0121] Step 3:

[0122] The server designs a cloud-native architecture based on the analysis results. The input is structural analysis data, and the output is a blueprint for the cloud-native architecture. The server generates modules and services suitable for the design framework.

[0123] Step 4:

[0124] The server translates legacy source code into a new programming language based on its designed cloud-native architecture. The input is legacy code and blueprints, and the output is the code translated into the new language. The server applies translation rules and reconstructs the code.

[0125] Step 5:

[0126] The server generates and runs automated verification cases for the converted code. The input is the code converted to the new language, and the output is the verification result. The server creates test cases using a generation AI model to verify that the code works according to specifications.

[0127] Step 6:

[0128] Users can view the results on their devices and visualize the progress and challenges until the migration is complete. Inputs are verification results and progress data obtained from the server, and output is a status report displayed on the device. Users can check the progress of the cloud migration through the device's interface.

[0129] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[0130] This invention relates to a system that enables companies to efficiently and effectively migrate their legacy systems to a modern cloud-native environment. This system incorporates an emotion engine that can optimize the system's responses and operations based on the user's emotional state.

[0131] To use the system, the user first sends legacy source code to the server via a terminal. The server analyzes the received source code, identifying its structure and dependencies. This allows the system to understand the overall architecture of the legacy code, enabling efficient processing in subsequent steps.

[0132] Next, the server uses generative AI technology to generate a cloud-native architecture design. This design has a microservices-based structure that is flexible and scalable, optimizing system performance. Based on the design, the server translates the original code into a new programming language, and generates and runs automated test cases to ensure the quality of the translated code.

[0133] Furthermore, the server uses natural language processing technology to analyze the business logic written in the original code and accurately applies that logic to the new code. It also proposes optimizations for optimizable parts of the business rules and implements them as needed.

[0134] A particularly noteworthy feature is the emotion engine built into the system. While the user is interacting with the system, the emotion engine determines their emotional state based on their voice, input speed, and the options they select. For example, if the system determines that the user is stressed, it adjusts the operation procedures and how information is presented to make the user more comfortable. Specifically, if the user is stressed by complicated operation steps, the emotion engine will provide simplified instructions to improve the user experience.

[0135] This system allows users to smoothly navigate the legacy system migration process, reducing emotional burden and improving work efficiency. Thus, the present invention demonstrates excellent effects not only from a technical standpoint but also from the perspective of improving the user experience.

[0136] The following describes the processing flow.

[0137] Step 1:

[0138] The user selects the legacy source code to migrate from their terminal and uploads it to the server. This operation is performed via the user interface, and the server stores the submitted files in a temporary storage location.

[0139] Step 2:

[0140] The server performs syntax analysis on the received code. Here, functions, variables, and dependencies within the code are identified, and a dependency map is generated. Based on this analysis information, the overall system structure is understood.

[0141] Step 3:

[0142] The server uses generative AI technology to automatically generate a cloud-native architecture design based on the analysis results. The design includes a microservices strategy and the specifications of the necessary APIs, which then leads to a rewrite of the code.

[0143] Step 4:

[0144] The server performs the code conversion process to the new programming language. Here, AI is used to efficiently convert the code into new code while preserving the functionality of the original code.

[0145] Step 5:

[0146] The server generates automated test cases for the newly converted code and runs these tests. The tests include unit tests and integration tests to ensure the code works correctly.

[0147] Step 6:

[0148] The server uses natural language processing techniques to analyze the business logic contained in the original code. Based on the results of this analysis, it applies the new code and verifies that the business logic functions correctly.

[0149] Step 7:

[0150] The emotion engine allows the server to monitor the user's emotional state. If stress or dissatisfaction is detected based on the user's response speed and interactions, the system automatically adjusts the operation flow and information presentation methods to optimize the user experience.

[0151] Step 8:

[0152] The server verifies that the converted code is deployable to the cloud environment. It provisions the necessary cloud resources, configures security settings, and finally notifies the user that the migration is complete.

[0153] (Example 2)

[0154] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the smart device 14 as the "terminal".

[0155] In today's technological environment, while there is a need to adapt outdated program code to the cloud, the migration process presents significant challenges, requiring considerable time and effort. Furthermore, a lack of user-friendly support that considers the emotional state of users leads to decreased usability. Against this backdrop, there is a need for efficient and emotionally resonant methods to migrate outdated program code to the cloud environment.

[0156] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[0157] In this invention, the server includes means for receiving outdated program code via an information processing device and analyzing its structure and relationships; means for generating a design utilizing virtualization technology from the analyzed outdated program code; and means for determining the emotional state based on the user's actions and providing operational support. This enables the efficient adaptation of outdated program code to a cloud environment and improves the user's operational experience.

[0158] An "information processing device" refers to hardware that has the function of receiving, processing, and analyzing data, and is connected via a network.

[0159] "Outdated program code" refers to programs used in older technological environments and software structures that are not compatible with the latest technological systems.

[0160] "Structural and interrelationship analysis" refers to the process of breaking down program code and visualizing its basic structure and interactions.

[0161] "Designing with virtualization technology" refers to a method of constructing a system architecture that is flexible and efficiently usable by using computing abstraction.

[0162] "Determining emotional state based on user actions" refers to the process of analyzing interaction data such as speech recognition and input speed to estimate the emotions of the person performing the action.

[0163] "Operational support" refers to methods of guidance and suggestions provided in real time to support users' efficient activities.

[0164] This invention relates to an information processing system for adapting outdated program code to an environment utilizing modern virtualization technology. The user sends the outdated program code to a server using a terminal. The terminal is a general-purpose computer with an internet connection. The server analyzes the received program code using a parsing library to understand its structure and relationships. Specifically, the server can use ANTLR or similar parsing tools.

[0165] The server then uses a generative AI model to generate a design that leverages the new virtualization technology. During this process, prompts are input to the AI ​​model. For example, the prompt "Redesign the outdated accounting system for a virtualized environment" might be used. This allows the server to design a flexible and scalable system architecture.

[0166] Furthermore, based on user actions, the server determines the user's emotional state and provides operational support. This emotional determination utilizes speech recognition technology and input data analysis (e.g., Google Speech Recognition). When the user experiences stress, the server adjusts the UI and operational instructions to improve the user experience. This enables the entire system to efficiently migrate outdated program code to an emotionally sensitive virtualization environment.

[0167] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0168] Step 1:

[0169] The user sends outdated program code to the server using a terminal. The input here is a program file selected and uploaded by the user. The terminal transmits this file over the network and forwards it to the server. The output is the program code received by the server.

[0170] Step 2:

[0171] The server parses the received program code. Specifically, it uses a parsing library (e.g., ANTLR) to extract the code's structure and dependencies. The input here is the program code, and the output is the parsed structure information and dependency data. This data is used in the next step.

[0172] Step 3:

[0173] Based on the analyzed information, the server generates a design utilizing virtualization technology using a generative AI model. The input is the structural information and dependency data obtained in step 2. The prompt "Design an outdated system for a virtualized environment" is entered, and the AI ​​model generates a new architectural design. The output is a design proposal based on virtualization technology.

[0174] Step 4:

[0175] The server converts the old program code into a new information processing language based on the generated design. The inputs are the design proposal obtained in step 3 and the original program code. The server uses a code conversion tool to migrate this into the new language, thereby generating new program code as output.

[0176] Step 5:

[0177] The server automatically generates and executes verification items for the newly converted program code. The input is the new program code. The server generates verification items using an automated testing tool and executes them. This allows the test results to be obtained as output, confirming the quality of the code.

[0178] Step 6:

[0179] The server analyzes the operational logic of the outdated program code and accurately applies that logic to the new program. The input is the code portion containing the original operational logic. The output is the new program code reflecting the analyzed operational logic.

[0180] Step 7:

[0181] The server uses user interaction data, such as voice and input speed, to determine the user's emotional state and provide operational support. Input includes voice samples and keystroke data. An emotion engine analyzes this data and provides support, such as adjusting the UI, if the user is experiencing stress. The output is an optimized user experience.

[0182] (Application Example 2)

[0183] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as a "server" and the smart device 14 as a "terminal".

[0184] Migrating legacy systems to a cloud-native environment is a significant burden due to their complex structure and dependencies. Furthermore, the emotional stress experienced by users during the migration process can reduce operational efficiency. Additionally, maintaining consistent quality while adapting to new technical specifications is not easy.

[0185] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means.

[0186] In this invention, the server includes means for analyzing software received from a legacy system and identifying its structure and dependencies, means for generating a cloud-native configuration from the analyzed software, and means for analyzing the user's emotional state and adjusting the user interface accordingly. This makes it possible to efficiently migrate legacy systems, reduce the emotional burden on users, and improve operational efficiency.

[0187] A "legacy system" is an information processing system built on older technologies and designs that continues to be used today.

[0188] "Cloud-native architecture" refers to a software design methodology optimized for cloud computing environments, including a microservices architecture that prioritizes flexibility and scalability.

[0189] "User emotional state" refers to the psychological state a user experiences while operating a system, including stress levels, satisfaction levels, and feelings of security.

[0190] "Means of adjusting the user interface" refers to a mechanism that dynamically changes the way the system is displayed and operated according to the user's emotional state, thereby improving the user's operational efficiency and comfort.

[0191] "Means for analyzing software and identifying its structure and dependencies" refers to techniques for analyzing the program code of legacy systems to reveal what components it is composed of and how those components relate to each other.

[0192] This system migrates legacy systems to a cloud-native environment and improves the user experience by analyzing user sentiment regarding their interactions.

[0193] The server first analyzes the software received from the legacy system to identify its structure and dependencies. This utilizes program analysis techniques to reveal the relationships between each module of the source code. Next, based on the analyzed information, it generates a cloud-native configuration. At this stage, it optimizes data flow and module interactions to design a more flexible and efficient system with new technical specifications.

[0194] To analyze the user's emotional state, an emotion engine is used to evaluate the voice tone and input speed obtained from the user interface. Specifically, speech recognition technology is used to convert voice input into text, and this text data is then analyzed by the emotion engine. The emotion engine has means to appropriately adjust the display and instructions on the operation screen based on the user's emotional state.

[0195] For example, if a user in the accounting department needs to quickly process a large amount of data during a busy period, the emotion engine will detect the user's stress level and automatically simplify the input interface, adjusting it to display only the necessary information, thereby reducing the user's workload.

[0196] An example of a prompt message would be, "We will analyze the user's voice track and automatically adjust the UI to simplify it if the voice tone becomes higher."

[0197] The software used includes a natural language processing engine for text analysis, an emotion engine for sentiment analysis, and a microservice configuration generator for cloud environment design. The servers are built to run on a cloud infrastructure to efficiently handle this data processing.

[0198] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[0199] Step 1:

[0200] The server receives source code from the legacy system. The source code of the legacy system is provided as input. The output is source code ready for analysis. This step converts the source code into a clean format to facilitate analysis.

[0201] Step 2:

[0202] The server analyzes the received source code and identifies its structure and dependencies. Legacy source code is used as input. The output generates information explicitly detailing the module structure and dependencies. Specifically, the dependencies between functions and classes within the code are stored in a database.

[0203] Step 3:

[0204] The server generates a cloud-native configuration based on the analyzed information. Identified structural and dependency data is used as input. The output is a new cloud-native design that prioritizes flexibility and efficiency. This step uses a microservices architecture to create the new blueprint.

[0205] Step 4:

[0206] The server converts legacy systems to new technical specifications based on a cloud-native configuration. Data from cloud-native design services is used as input. The output is code conforming to the new technical specifications. This conversion utilizes a generative AI model to optimize the code.

[0207] Step 5:

[0208] The server automatically generates and implements evaluation criteria based on the converted technical specifications. The input is the code of the new technical specifications. The output is quality assurance based on test results. Specifically, the server generates and executes test scripts to detect errors in the code.

[0209] Step 6:

[0210] The device collects the user's voice tone and input speed and sends them to the emotion engine. The inputs used are the user's voice data and input speed. The output is data representing the user's emotional state. This step involves acquiring real-time data from the device's microphone and keyboard.

[0211] Step 7:

[0212] The server adjusts the user interface based on the user's emotional state. Emotional state data is used as input. The output is an optimized user interface. Specifically, it minimizes the information displayed and makes it easier for the user to access the information they need most.

[0213] Step 8:

[0214] Users can continue operating comfortably through a well-tuned interface. The input is an optimized interface; the output is a stress-free operating experience. This improves operational efficiency and reduces the burden of work.

[0215] The specific processing unit 290 transmits the result of the specific processing to the smart device 14. In the smart device 14, the control unit 46A causes the output device 40 to output the result of the specific processing. The microphone 38B acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0216] Data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of data generation model 58 is ChatGPT (registered trademark) (Internet search).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0217] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the smart device 14.

[0218] [Second Embodiment]

[0219] Figure 3 shows an example of the configuration of the data processing system 210 according to the second embodiment.

[0220] As shown in Figure 3, the data processing system 210 includes a data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0221] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0222] The smart glasses 214 include a computer 36, a microphone 238, a speaker 240, a camera 42, and a communication interface 44. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, and camera 42 are also connected to the bus 52.

[0223] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

[0224] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the area around the user 20 (for example, an imaging range defined by a field of view equivalent to the width of a typical healthy person's field of vision).

[0225] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[0226] Figure 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Figure 4, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[0227] The specific processing program 56 is an example of a "program" relating to the technology of this disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0228] The storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0229] In the smart glasses 214, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0230] Next, the identification processing performed by the identification processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal".

[0231] The system according to the present invention aims to efficiently migrate a company's legacy systems to a modern cloud-native environment. When implementing this system, each component works in cooperation with each other as follows, achieving a seamless migration process as a whole.

[0232] First, the user inputs the source code of the legacy system to be migrated into the system via a terminal. This source code is written in older languages ​​and frameworks. When the server receives this code, it first performs syntax analysis to understand the code's structure and dependencies. This analysis helps to understand the overall picture of the source code and identify inefficiencies and risks associated with the migration.

[0233] Based on the analysis results, the server utilizes generative AI technology to generate a cloud-native architecture design. The generated design is based on a microservices structure, achieving flexible scalability. At this stage, it is defined which parts will be adapted to the new environment and how.

[0234] As a concrete example, consider an old COBOL-based inventory management system. The business logic of this system is to automatically replenish inventory when it falls below a certain level. The server analyzes this logic and generates a design so that the same functionality can be applied in a new cloud environment.

[0235] Next, the server uses a conversion mechanism to convert the original COBOL code into a new programming language, such as Java or Python. This conversion not only replaces the language of the code but also optimizes the entire program to be runnable on the cloud.

[0236] Since the converted code cannot be tested directly, the server automatically generates and executes test cases. The tests mainly consist of unit tests and integration tests to verify that the entire system functions correctly. This automated testing method ensures high accuracy in the quality of the converted code and minimizes operational problems after migration.

[0237] Furthermore, the server utilizes natural language processing technology to appropriately analyze and apply the business logic within the legacy source code, ensuring that the new system meets the original business requirements. Optimization of the business logic is also performed as needed.

[0238] Through this series of processes, users can achieve advanced system migration with minimal need for specialized knowledge or technical support. Therefore, the embodiment of the present invention achieves reduced migration costs, mitigated migration risks, and improved operational flexibility.

[0239] The following describes the processing flow.

[0240] Step 1:

[0241] The user uploads the legacy source code to be migrated to the server via their terminal. The server saves the received code to storage and prepares it for analysis.

[0242] Step 2:

[0243] The server begins syntax analysis of the uploaded source code. This analysis helps to understand the overall structure of the code, functions, variables, and dependencies, and generates a dependency map.

[0244] Step 3:

[0245] The server uses generative AI technology to generate cloud-native architecture designs based on analysis results. For example, it designs microservice models and API interfaces for service partitioning.

[0246] Step 4:

[0247] The server translates the legacy source code into a new programming language of its choice, according to the generated design. The translation ensures that each function and data structure functions correctly in the new language.

[0248] Step 5:

[0249] The server uses AI to generate automated test cases for the newly converted code and runs these tests. These tests include unit tests and integration tests to verify the quality and accuracy of the code.

[0250] Step 6:

[0251] The server uses natural language processing to extract the business logic contained in the original code and verify that it is correctly reflected in the new code. If necessary, it suggests optimizations to the business logic.

[0252] Step 7:

[0253] As a final check, the server verifies that the new system can be deployed to the cloud environment. This includes checking resource settings and security policies.

[0254] Step 8:

[0255] The server sends a notification to the user that the migration is complete and finally verifies that the migrated system meets the required performance and functional requirements.

[0256] (Example 1)

[0257] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal".

[0258] Many corporate information processing environments still operate legacy systems built on outdated technological foundations, often unable to adapt to new technologies. This makes migrating to the latest distributed processing infrastructure difficult, resulting in increasing operational costs and technical debt. Furthermore, maintaining and optimizing business rules during the conversion process is crucial, necessitating complete automation.

[0259] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0260] In this invention, the server includes means for receiving legacy information and analyzing its structure and dependencies, means for generating a distributed processing platform design from the analyzed legacy information, and means for converting the legacy information into a new programming syntax based on the generated distributed processing platform design. This enables a smooth transition of legacy systems to the latest technological environment and reduces operational costs.

[0261] "Legacy information" refers to existing information systems built on older technological foundations that are difficult to adapt to the latest technological environment.

[0262] "Structure" refers to the internal organization of information or a system, as well as the relationships between its elements.

[0263] "Dependency" refers to a state in which elements of different systems or structures are mutually dependent on each other.

[0264] "Means of analysis" refers to techniques and methods for breaking down information and understanding its structure and characteristics.

[0265] A "distributed processing infrastructure" refers to a structure or technology that distributes information processing across multiple independent computers.

[0266] "Means of generating a design" refers to methods and techniques for creating a system design or plan based on a specific purpose.

[0267] "Programming syntax" refers to the format and rules of code used to specify behavior in a particular programming language.

[0268] "Evaluation criteria" refers to standards or rules established to verify the operation and performance of new information or systems.

[0269] "Business rules" refer to regulations that define the conditions and methods for business processes executed within an organization or system.

[0270] "Natural language processing technology" refers to the techniques and methods used to understand and process human language using computers.

[0271] This invention provides a system for migrating an enterprise's outdated information processing system to a state-of-the-art distributed processing infrastructure environment. Specific embodiments thereof are described below.

[0272] Users input foundational information from the company's existing information systems into the server via a terminal. This foundational information is written using outdated programming techniques and frameworks.

[0273] The server uses a syntax analysis tool (e.g., ANTLR) to parse the input information. This clarifies the structure and dependencies of the information, identifying inefficiencies and risks associated with the migration.

[0274] Based on the analysis results, the server utilizes a generative AI model (e.g., OpenAI's GPT) to generate a new distributed processing platform design. This design is particularly adapted to cloud services (e.g., AWS and GCP) and is based on a microservices architecture.

[0275] Next, the server uses a conversion engine to convert the original information into a new programming syntax, such as Java or Python. This conversion not only replaces the syntax but also optimizes it to suit the new platform.

[0276] Subsequently, to verify the code's operation, the server automatically generates and executes evaluation criteria. These tests primarily consist of unit tests and integration tests, confirming the proper functioning of the entire system.

[0277] Furthermore, the server uses natural language processing technology to appropriately analyze and apply the business rules of the base information, and confirm that the new information meets the original business requirements. If necessary, it also performs optimization of the business rules.

[0278] As a specific example, consider a COBOL-based inventory management system. In the business rules of this system, there is a rule that when the inventory falls below a certain amount, replenishment is automatically carried out. The server analyzes this rule and configures the system so that it operates similarly on the new distributed base.

[0279] As an example of the prompt sentence, input as follows:

[0280] "Analyze this COBOL-based inventory management system and generate Java code adapted to the cloud-native environment."

[0281] The flow of the specific process in Example 1 will be described using FIG. 11.

[0282] Step 1:

[0283] The user inputs the base information of the legacy system to the server via the terminal. This information is described in an old programming language (e.g., COBOL). This input information becomes the basis for processing.

[0284] Step 2:

[0285] The server performs syntax analysis based on the input information. At this stage, a syntax analysis tool (e.g., ANTLR) is used to analyze the structure and dependencies of the code. As output, an internal structure and dependency map of the code are obtained.

[0286] Step 3:

[0287] Based on the analysis results, the server generates a distributed processing infrastructure design using a generated AI model. It receives the analysis results as input and outputs a design document for a microservice architecture suitable for a cloud environment.

[0288] Step 4:

[0289] The server runs a conversion engine that translates the original programming language into a new language (e.g., Java, Python). This process optimizes the code based on the design document and outputs the converted program.

[0290] Step 5:

[0291] The converted code enters a testing stage to verify that it works correctly. The server automatically generates unit and integration tests and runs them using testing tools. Based on the test results, the code is evaluated to see if it functions properly.

[0292] Step 6:

[0293] Furthermore, the server uses natural language processing technology to analyze the business rules contained in the underlying information. The acquired business rules are applied to the converted information to verify whether the required business functions are maintained. The output is the result of the business rule compliance verification.

[0294] (Application Example 1)

[0295] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[0296] In recent years, legacy systems used within companies have become unable to keep up with the rapidly changing business environment, resulting in a significant burden for their maintenance and operation. Furthermore, migrating to a cloud-native environment requires technical knowledge and effort, posing a major obstacle, especially for small and medium-sized enterprises. Moreover, managing the progress of the migration process and detecting problems early is difficult, leading to project delays and increased costs. Therefore, a system capable of efficient and real-time migration is necessary.

[0297] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0298] In this invention, the server includes means for receiving legacy source code and analyzing its structure and dependencies, means for generating a cloud-native architecture from the analyzed legacy source code, and means for scanning the source code using a mobile terminal or wireless communication device and visualizing the analysis results. This enables users to smoothly proceed with the migration process of legacy systems to the cloud, and to understand the situation and solve problems in real time.

[0299] "Legacy source code" refers to older program code that a company or organization has used for a long period of time, and is usually written using older programming languages ​​or technologies.

[0300] "Structural and dependency analysis" is the process of identifying and understanding the internal structure of program code and its interdependencies with other components.

[0301] A "cloud-native architecture" is a design optimized for cloud environments, offering flexibility and scalability, and is often based on a microservices architecture.

[0302] "Program language conversion" refers to the process of converting specific program code into a different program language to make it operational in a new environment.

[0303] "Automatic verification case" refers to a test scenario automatically generated to verify the accuracy and functionality of the converted program code.

[0304] "Business rules" refer to the business logics and rules defined within a legacy system that need to be reproduced in the new system.

[0305] "Mobile terminal or wireless communication device" refers to an electronic device that performs information processing using wireless communication technology, including smartphones and smart glasses.

[0306] "Visualization of analysis results" refers to the process of presenting the analyzed data and progress status in a user-friendly format.

[0307] "External computing environment" refers to an environment for performing computing processes using cloud services or remote servers.

[0308] The system for realizing this invention provides a series of processes for efficiently performing cloud migration. The server receives the legacy source code scanned by the mobile terminal owned by the user. This terminal is a general portable information processing device and can utilize, for example, smartphones and smart glasses.

[0309] First, the server uses a generative AI model to analyze in detail the structure and dependencies of the legacy source code. Based on the data obtained from this analysis, the server designs an optimal cloud-native architecture. This architecture is flexible and scalable and is mainly based on a microservices architecture.

[0310] Next, the server translates the legacy source code into a new programming language based on the analysis results. This translation is not a direct substitution of code between languages, but includes optimizations suitable for the cloud environment. The server efficiently performs this process by utilizing external computing environments, such as Google Cloud Platform or Amazon Web Services.

[0311] The newly converted source code is verified for functionality and accuracy using automatically generated validation cases. This ensures high quality and confirms that the migrated system operates correctly. Users can visualize and understand this progress and any remaining issues via their mobile devices.

[0312] As a concrete example, users can use smart glasses during meetings to monitor the status of the cloud migration process and participate in real-time discussions. An example of a prompt is, "Analyze the code of this COBOL-based inventory management system and generate a cloud-native design based on a microservices architecture." This prompt allows the generating AI model to support the cloud migration quickly and effectively.

[0313] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0314] Step 1:

[0315] The user scans legacy source code using a terminal and sends it to the server. The input is a code image captured by the terminal's camera. The terminal converts the image to text format and sends that text data to the server.

[0316] Step 2:

[0317] The server uses a generative AI model to analyze the structure and dependencies of the received text data. The input is the scanned source code text data, and the output is the code's structural analysis data. The server identifies dependencies and analyzes the data flow and constraints within the program.

[0318] Step 3:

[0319] The server designs a cloud-native architecture based on the analysis results. The input is structural analysis data, and the output is a blueprint for the cloud-native architecture. The server generates modules and services suitable for the design framework.

[0320] Step 4:

[0321] The server translates legacy source code into a new programming language based on its designed cloud-native architecture. The input is legacy code and blueprints, and the output is the code translated into the new language. The server applies translation rules and reconstructs the code.

[0322] Step 5:

[0323] The server generates and runs automated verification cases for the converted code. The input is the code converted to the new language, and the output is the verification result. The server creates test cases using a generation AI model to verify that the code works according to specifications.

[0324] Step 6:

[0325] Users can view the results on their devices and visualize the progress and challenges until the migration is complete. Inputs are verification results and progress data obtained from the server, and output is a status report displayed on the device. Users can check the progress of the cloud migration through the device's interface.

[0326] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[0327] This invention relates to a system that enables companies to efficiently and effectively migrate their legacy systems to a modern cloud-native environment. This system incorporates an emotion engine that can optimize the system's responses and operations based on the user's emotional state.

[0328] To use the system, the user first sends legacy source code to the server via a terminal. The server analyzes the received source code, identifying its structure and dependencies. This allows the system to understand the overall architecture of the legacy code, enabling efficient processing in subsequent steps.

[0329] Next, the server uses generative AI technology to generate a cloud-native architecture design. This design has a microservices-based structure that is flexible and scalable, optimizing system performance. Based on the design, the server translates the original code into a new programming language, and generates and runs automated test cases to ensure the quality of the translated code.

[0330] Furthermore, the server uses natural language processing technology to analyze the business logic written in the original code and accurately applies that logic to the new code. It also proposes optimizations for optimizable parts of the business rules and implements them as needed.

[0331] A particularly noteworthy feature is the emotion engine built into the system. While the user is interacting with the system, the emotion engine determines their emotional state based on their voice, input speed, and the options they select. For example, if the system determines that the user is stressed, it adjusts the operation procedures and how information is presented to make the user more comfortable. Specifically, if the user is stressed by complicated operation steps, the emotion engine will provide simplified instructions to improve the user experience.

[0332] This system allows users to smoothly navigate the legacy system migration process, reducing emotional burden and improving work efficiency. Thus, the present invention demonstrates excellent effects not only from a technical standpoint but also from the perspective of improving the user experience.

[0333] The following describes the processing flow.

[0334] Step 1:

[0335] The user selects the legacy source code to migrate from their terminal and uploads it to the server. This operation is performed via the user interface, and the server stores the submitted files in a temporary storage location.

[0336] Step 2:

[0337] The server performs syntax analysis on the received code. Here, functions, variables, and dependencies within the code are identified, and a dependency map is generated. Based on this analysis information, the overall system structure is understood.

[0338] Step 3:

[0339] The server uses generative AI technology to automatically generate a cloud-native architecture design based on the analysis results. The design includes a microservices strategy and the specifications of the necessary APIs, which then leads to a rewrite of the code.

[0340] Step 4:

[0341] The server performs the code conversion process to the new programming language. Here, AI is used to efficiently convert the code into new code while preserving the functionality of the original code.

[0342] Step 5:

[0343] The server generates automated test cases for the newly converted code and runs these tests. The tests include unit tests and integration tests to ensure the code works correctly.

[0344] Step 6:

[0345] The server uses natural language processing techniques to analyze the business logic contained in the original code. Based on the results of this analysis, it applies the new code and verifies that the business logic functions correctly.

[0346] Step 7:

[0347] The emotion engine allows the server to monitor the user's emotional state. If stress or dissatisfaction is detected based on the user's response speed and interactions, the system automatically adjusts the operation flow and information presentation methods to optimize the user experience.

[0348] Step 8:

[0349] The server verifies that the converted code is deployable to the cloud environment. It provisions the necessary cloud resources, configures security settings, and finally notifies the user that the migration is complete.

[0350] (Example 2)

[0351] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal".

[0352] In today's technological environment, while there is a need to adapt outdated program code to the cloud, the migration process presents significant challenges, requiring considerable time and effort. Furthermore, a lack of user-friendly support that considers the emotional state of users leads to decreased usability. Against this backdrop, there is a need for efficient and emotionally resonant methods to migrate outdated program code to the cloud environment.

[0353] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[0354] In this invention, the server includes means for receiving outdated program code via an information processing device and analyzing its structure and relationships; means for generating a design utilizing virtualization technology from the analyzed outdated program code; and means for determining the emotional state based on the user's actions and providing operational support. This enables the efficient adaptation of outdated program code to a cloud environment and improves the user's operational experience.

[0355] An "information processing device" refers to hardware that has the function of receiving, processing, and analyzing data, and is connected via a network.

[0356] "Outdated program code" refers to programs used in older technological environments and software structures that are not compatible with the latest technological systems.

[0357] "Structural and interrelationship analysis" refers to the process of breaking down program code and visualizing its basic structure and interactions.

[0358] "Designing with virtualization technology" refers to a method of constructing a system architecture that is flexible and efficiently usable by using computing abstraction.

[0359] "Determining emotional state based on user actions" refers to the process of analyzing interaction data such as speech recognition and input speed to estimate the emotions of the person performing the action.

[0360] "Operational support" refers to methods of guidance and suggestions provided in real time to support users' efficient activities.

[0361] This invention relates to an information processing system for adapting outdated program code to an environment utilizing modern virtualization technology. The user sends the outdated program code to a server using a terminal. The terminal is a general-purpose computer with an internet connection. The server analyzes the received program code using a parsing library to understand its structure and relationships. Specifically, the server can use ANTLR or similar parsing tools.

[0362] The server then uses a generative AI model to generate a design that leverages the new virtualization technology. During this process, prompts are input to the AI ​​model. For example, the prompt "Redesign the outdated accounting system for a virtualized environment" might be used. This allows the server to design a flexible and scalable system architecture.

[0363] Furthermore, based on user actions, the server determines the user's emotional state and provides operational support. This emotional determination utilizes speech recognition technology and input data analysis (e.g., Google Speech Recognition). When the user experiences stress, the server adjusts the UI and operational instructions to improve the user experience. This enables the entire system to efficiently migrate outdated program code to an emotionally sensitive virtualization environment.

[0364] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0365] Step 1:

[0366] The user sends outdated program code to the server using a terminal. The input here is a program file selected and uploaded by the user. The terminal transmits this file over the network and forwards it to the server. The output is the program code received by the server.

[0367] Step 2:

[0368] The server parses the received program code. Specifically, it uses a parsing library (e.g., ANTLR) to extract the code's structure and dependencies. The input here is the program code, and the output is the parsed structure information and dependency data. This data is used in the next step.

[0369] Step 3:

[0370] Based on the analyzed information, the server generates a design utilizing virtualization technology using a generative AI model. The input is the structural information and dependency data obtained in step 2. The prompt "Design an outdated system for a virtualized environment" is entered, and the AI ​​model generates a new architectural design. The output is a design proposal based on virtualization technology.

[0371] Step 4:

[0372] The server converts the old program code into a new information processing language based on the generated design. The inputs are the design proposal obtained in step 3 and the original program code. The server uses a code conversion tool to migrate this into the new language, thereby generating new program code as output.

[0373] Step 5:

[0374] The server automatically generates and executes verification items for the newly converted program code. The input is the new program code. The server generates verification items using an automated testing tool and executes them. This allows the test results to be obtained as output, confirming the quality of the code.

[0375] Step 6:

[0376] The server analyzes the operational logic of the outdated program code and accurately applies that logic to the new program. The input is the code portion containing the original operational logic. The output is the new program code reflecting the analyzed operational logic.

[0377] Step 7:

[0378] The server uses user interaction data, such as voice and input speed, to determine the user's emotional state and provide operational support. Input includes voice samples and keystroke data. An emotion engine analyzes this data and provides support, such as adjusting the UI, if the user is experiencing stress. The output is an optimized user experience.

[0379] (Application Example 2)

[0380] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[0381] Migrating legacy systems to a cloud-native environment is a significant burden due to their complex structure and dependencies. Furthermore, the emotional stress experienced by users during the migration process can reduce operational efficiency. Additionally, maintaining consistent quality while adapting to new technical specifications is not easy.

[0382] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means.

[0383] In this invention, the server includes means for analyzing software received from a legacy system and identifying its structure and dependencies, means for generating a cloud-native configuration from the analyzed software, and means for analyzing the user's emotional state and adjusting the user interface accordingly. This makes it possible to efficiently migrate legacy systems, reduce the emotional burden on users, and improve operational efficiency.

[0384] A "legacy system" is an information processing system built on older technologies and designs that continues to be used today.

[0385] "Cloud-native architecture" refers to a software design methodology optimized for cloud computing environments, including a microservices architecture that prioritizes flexibility and scalability.

[0386] "User emotional state" refers to the psychological state a user experiences while operating a system, including stress levels, satisfaction levels, and feelings of security.

[0387] "Means of adjusting the user interface" refers to a mechanism that dynamically changes the way the system is displayed and operated according to the user's emotional state, thereby improving the user's operational efficiency and comfort.

[0388] "Means for analyzing software and identifying its structure and dependencies" refers to techniques for analyzing the program code of legacy systems to reveal what components it is composed of and how those components relate to each other.

[0389] This system migrates legacy systems to a cloud-native environment and improves the user experience by analyzing user sentiment regarding their interactions.

[0390] The server first analyzes the software received from the legacy system to identify its structure and dependencies. This utilizes program analysis techniques to reveal the relationships between each module of the source code. Next, based on the analyzed information, it generates a cloud-native configuration. At this stage, it optimizes data flow and module interactions to design a more flexible and efficient system with new technical specifications.

[0391] To analyze the user's emotional state, an emotion engine is used to evaluate the voice tone and input speed obtained from the user interface. Specifically, speech recognition technology is used to convert voice input into text, and this text data is then analyzed by the emotion engine. The emotion engine has means to appropriately adjust the display and instructions on the operation screen based on the user's emotional state.

[0392] For example, if a user in the accounting department needs to quickly process a large amount of data during a busy period, the emotion engine will detect the user's stress level and automatically simplify the input interface, adjusting it to display only the necessary information, thereby reducing the user's workload.

[0393] An example of a prompt message would be, "We will analyze the user's voice track and automatically adjust the UI to simplify it if the voice tone becomes higher."

[0394] The software used includes a natural language processing engine for text analysis, an emotion engine for sentiment analysis, and a microservice configuration generator for cloud environment design. The servers are built to run on a cloud infrastructure to efficiently handle this data processing.

[0395] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[0396] Step 1:

[0397] The server receives source code from the legacy system. The source code of the legacy system is provided as input. The output is source code ready for analysis. This step converts the source code into a clean format to facilitate analysis.

[0398] Step 2:

[0399] The server analyzes the received source code and identifies its structure and dependencies. Legacy source code is used as input. The output generates information explicitly detailing the module structure and dependencies. Specifically, the dependencies between functions and classes within the code are stored in a database.

[0400] Step 3:

[0401] The server generates a cloud-native configuration based on the analyzed information. Identified structural and dependency data is used as input. The output is a new cloud-native design that prioritizes flexibility and efficiency. This step uses a microservices architecture to create the new blueprint.

[0402] Step 4:

[0403] The server converts legacy systems to new technical specifications based on a cloud-native configuration. Data from cloud-native design services is used as input. The output is code conforming to the new technical specifications. This conversion utilizes a generative AI model to optimize the code.

[0404] Step 5:

[0405] The server automatically generates and implements evaluation criteria based on the converted technical specifications. The input is the code of the new technical specifications. The output is quality assurance based on test results. Specifically, the server generates and executes test scripts to detect errors in the code.

[0406] Step 6:

[0407] The device collects the user's voice tone and input speed and sends them to the emotion engine. The inputs used are the user's voice data and input speed. The output is data representing the user's emotional state. This step involves acquiring real-time data from the device's microphone and keyboard.

[0408] Step 7:

[0409] The server adjusts the user interface based on the user's emotional state. Emotional state data is used as input. The output is an optimized user interface. Specifically, it minimizes the information displayed and makes it easier for the user to access the information they need most.

[0410] Step 8:

[0411] Users can continue operating comfortably through a well-tuned interface. The input is an optimized interface; the output is a stress-free operating experience. This improves operational efficiency and reduces the burden of work.

[0412] The specific processing unit 290 transmits the result of the specific processing to the smart glasses 214. In the smart glasses 214, the control unit 46A causes the speaker 240 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[0413] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0414] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the smart glasses 214.

[0415] [Third Embodiment]

[0416] Figure 5 shows an example of the configuration of the data processing system 310 according to the third embodiment.

[0417] As shown in Figure 5, the data processing system 310 includes a data processing device 12 and a headset terminal 314. An example of the data processing device 12 is a server.

[0418] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0419] The headset terminal 314 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a display 343. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and display 343 are also connected to the bus 52.

[0420] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

[0421] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the area around the user 20 (for example, an imaging range defined by a field of view equivalent to the width of a typical healthy person's field of vision).

[0422] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[0423] Figure 6 shows an example of the main functions of the data processing device 12 and the headset terminal 314. As shown in Figure 6, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[0424] The specific processing program 56 is an example of a "program" relating to the technology of this disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0425] The storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0426] In the headset terminal 314, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0427] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the headset terminal 314 will be referred to as the "terminal".

[0428] The system according to the present invention aims to efficiently migrate a company's legacy systems to a modern cloud-native environment. When implementing this system, each component works in cooperation with each other as follows, achieving a seamless migration process as a whole.

[0429] First, the user inputs the source code of the legacy system to be migrated into the system via a terminal. This source code is written in older languages ​​and frameworks. When the server receives this code, it first performs syntax analysis to understand the code's structure and dependencies. This analysis helps to understand the overall picture of the source code and identify inefficiencies and risks associated with the migration.

[0430] Based on the analysis results, the server utilizes generative AI technology to generate a cloud-native architecture design. The generated design is based on a microservices structure, achieving flexible scalability. At this stage, it is defined which parts will be adapted to the new environment and how.

[0431] As a concrete example, consider an old COBOL-based inventory management system. The business logic of this system is to automatically replenish inventory when it falls below a certain level. The server analyzes this logic and generates a design so that the same functionality can be applied in a new cloud environment.

[0432] Next, the server uses a conversion mechanism to convert the original COBOL code into a new programming language, such as Java or Python. This conversion not only replaces the language of the code but also optimizes the entire program to be runnable on the cloud.

[0433] Since the converted code cannot be tested directly, the server automatically generates and executes test cases. The tests mainly consist of unit tests and integration tests to verify that the entire system functions correctly. This automated testing method ensures high accuracy in the quality of the converted code and minimizes operational problems after migration.

[0434] Furthermore, the server utilizes natural language processing technology to appropriately analyze and apply the business logic within the legacy source code, ensuring that the new system meets the original business requirements. Optimization of the business logic is also performed as needed.

[0435] Through this series of processes, users can achieve advanced system migration with minimal need for specialized knowledge or technical support. Therefore, the embodiment of the present invention achieves reduced migration costs, mitigated migration risks, and improved operational flexibility.

[0436] The following describes the processing flow.

[0437] Step 1:

[0438] The user uploads the legacy source code to be migrated to the server via their terminal. The server saves the received code to storage and prepares it for analysis.

[0439] Step 2:

[0440] The server begins syntax analysis of the uploaded source code. This analysis helps to understand the overall structure of the code, functions, variables, and dependencies, and generates a dependency map.

[0441] Step 3:

[0442] The server uses generative AI technology to generate cloud-native architecture designs based on analysis results. For example, it designs microservice models and API interfaces for service partitioning.

[0443] Step 4:

[0444] The server translates the legacy source code into a new programming language of its choice, according to the generated design. The translation ensures that each function and data structure functions correctly in the new language.

[0445] Step 5:

[0446] The server uses AI to generate automated test cases for the newly converted code and runs these tests. These tests include unit tests and integration tests to verify the quality and accuracy of the code.

[0447] Step 6:

[0448] The server uses natural language processing to extract the business logic contained in the original code and verify that it is correctly reflected in the new code. If necessary, it suggests optimizations to the business logic.

[0449] Step 7:

[0450] As a final check, the server verifies that the new system can be deployed to the cloud environment. This includes checking resource settings and security policies.

[0451] Step 8:

[0452] The server sends a notification to the user that the migration is complete and finally verifies that the migrated system meets the required performance and functional requirements.

[0453] (Example 1)

[0454] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[0455] Many corporate information processing environments still operate legacy systems built on outdated technological foundations, often unable to adapt to new technologies. This makes migrating to the latest distributed processing infrastructure difficult, resulting in increasing operational costs and technical debt. Furthermore, maintaining and optimizing business rules during the conversion process is crucial, necessitating complete automation.

[0456] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0457] In this invention, the server includes means for receiving legacy information and analyzing its structure and dependencies, means for generating a distributed processing platform design from the analyzed legacy information, and means for converting the legacy information into a new programming syntax based on the generated distributed processing platform design. This enables a smooth transition of legacy systems to the latest technological environment and reduces operational costs.

[0458] "Legacy information" refers to existing information systems built on older technological foundations that are difficult to adapt to the latest technological environment.

[0459] "Structure" refers to the internal organization of information or a system, as well as the relationships between its elements.

[0460] "Dependency" refers to a state in which elements of different systems or structures are mutually dependent on each other.

[0461] "Means of analysis" refers to techniques and methods for breaking down information and understanding its structure and characteristics.

[0462] A "distributed processing infrastructure" refers to a structure or technology that distributes information processing across multiple independent computers.

[0463] "Means of generating a design" refers to methods and techniques for creating a system design or plan based on a specific purpose.

[0464] "Programming syntax" refers to the format and rules of code used to specify behavior in a particular programming language.

[0465] "Evaluation criteria" refers to standards or rules established to verify the operation and performance of new information or systems.

[0466] "Business rules" refer to regulations that define the conditions and methods for business processes executed within an organization or system.

[0467] "Natural language processing technology" refers to the techniques and methods used to understand and process human language using computers.

[0468] This invention provides a system for migrating an enterprise's outdated information processing system to a state-of-the-art distributed processing infrastructure environment. Specific embodiments thereof are described below.

[0469] Users input foundational information from the company's existing information systems into the server via a terminal. This foundational information is written using outdated programming techniques and frameworks.

[0470] The server uses a syntax analysis tool (e.g., ANTLR) to parse the input information. This clarifies the structure and dependencies of the information, identifying inefficiencies and risks associated with the migration.

[0471] Based on the analysis results, the server utilizes a generative AI model (e.g., OpenAI's GPT) to generate a new distributed processing platform design. This design is particularly adapted to cloud services (e.g., AWS and GCP) and is based on a microservices architecture.

[0472] Next, the server uses a conversion engine to convert the original information into a new programming syntax, such as Java or Python. This conversion not only replaces the syntax but also optimizes it to suit the new platform.

[0473] Subsequently, to verify the code's operation, the server automatically generates and executes evaluation criteria. These tests primarily consist of unit tests and integration tests, confirming the proper functioning of the entire system.

[0474] Furthermore, the server uses natural language processing technology to appropriately analyze and apply the business rules of the underlying information, and verifies that the new information meets the original business requirements. If necessary, it also optimizes the business rules.

[0475] As a concrete example, consider a COBOL-based inventory management system. One of the system's operational rules is to automatically replenish inventory when it falls below a certain level. The server analyzes this rule and configures the system to function similarly on the new distributed infrastructure.

[0476] For example, enter the following prompt:

[0477] "Analyze this COBOL-based inventory management system and generate Java code adapted for a cloud-native environment."

[0478] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0479] Step 1:

[0480] The user inputs foundational information from the legacy system into the server via a terminal. This information is written in an older programming language (e.g., COBOL). This input information forms the basis for processing.

[0481] Step 2:

[0482] The server performs syntax analysis based on the input information. At this stage, a syntax analysis tool (e.g., ANTLR) is used to analyze the code structure and dependencies. The output is the internal structure of the code and a dependency map.

[0483] Step 3:

[0484] Based on the analysis results, the server generates a distributed processing infrastructure design using a generated AI model. It receives the analysis results as input and outputs a design document for a microservice architecture suitable for a cloud environment.

[0485] Step 4:

[0486] The server runs a conversion engine that translates the original programming language into a new language (e.g., Java, Python). This process optimizes the code based on the design document and outputs the converted program.

[0487] Step 5:

[0488] The converted code enters a testing stage to verify that it works correctly. The server automatically generates unit and integration tests and runs them using testing tools. Based on the test results, the code is evaluated to see if it functions properly.

[0489] Step 6:

[0490] Furthermore, the server uses natural language processing technology to analyze the business rules contained in the underlying information. The acquired business rules are applied to the converted information to verify whether the required business functions are maintained. The output is the result of the business rule compliance verification.

[0491] (Application Example 1)

[0492] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[0493] In recent years, legacy systems used within companies have become unable to keep up with the rapidly changing business environment, resulting in a significant burden for their maintenance and operation. Furthermore, migrating to a cloud-native environment requires technical knowledge and effort, posing a major obstacle, especially for small and medium-sized enterprises. Moreover, managing the progress of the migration process and detecting problems early is difficult, leading to project delays and increased costs. Therefore, a system capable of efficient and real-time migration is necessary.

[0494] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0495] In this invention, the server includes means for receiving legacy source code and analyzing its structure and dependencies, means for generating a cloud-native architecture from the analyzed legacy source code, and means for scanning the source code using a mobile terminal or wireless communication device and visualizing the analysis results. This enables users to smoothly proceed with the migration process of legacy systems to the cloud, and to understand the situation and solve problems in real time.

[0496] "Legacy source code" refers to older program code that a company or organization has used for a long period of time, and is usually written using older programming languages ​​or technologies.

[0497] "Structural and dependency analysis" is the process of identifying and understanding the internal structure of program code and its interdependencies with other components.

[0498] A "cloud-native architecture" is a design optimized for cloud environments, offering flexibility and scalability, and is often based on a microservices architecture.

[0499] "Programming language conversion" is the process of translating specific program code into a different programming language so that it can run in a new environment.

[0500] An "automatic verification case" is a test scenario that is automatically generated to verify the accuracy and functionality of the converted program code.

[0501] "Business rules" are the business logic and rules defined within a legacy system that need to be reproduced in the new system.

[0502] "Mobile devices or wireless communication devices" refer to electronic devices that use wireless communication technology to process information, including smartphones and smart glasses.

[0503] "Visualization of analysis results" is the process of displaying the analyzed data and progress in a format that is easy for users to understand.

[0504] An "external computing environment" refers to an environment used for performing computational processing using cloud services or remote servers.

[0505] The system for realizing this invention provides a series of processes for efficiently migrating to the cloud. The server receives legacy source code scanned by a user's mobile device. This device is a common portable information processing device, such as a smartphone or smart glasses.

[0506] First, the server uses a generative AI model to analyze the structure and dependencies of the legacy source code in detail. Based on the data obtained from this analysis, the server designs an optimal cloud-native architecture. This architecture is flexible and scalable, and is primarily based on a microservices architecture.

[0507] Next, the server translates the legacy source code into a new programming language based on the analysis results. This translation is not a direct substitution of code between languages, but includes optimizations suitable for the cloud environment. The server efficiently performs this process by utilizing external computing environments, such as Google Cloud Platform or Amazon Web Services.

[0508] The newly converted source code is verified for functionality and accuracy using automatically generated validation cases. This ensures high quality and confirms that the migrated system operates correctly. Users can visualize and understand this progress and any remaining issues via their mobile devices.

[0509] As a concrete example, users can use smart glasses during meetings to monitor the status of the cloud migration process and participate in real-time discussions. An example of a prompt is, "Analyze the code of this COBOL-based inventory management system and generate a cloud-native design based on a microservices architecture." This prompt allows the generating AI model to support the cloud migration quickly and effectively.

[0510] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0511] Step 1:

[0512] The user scans legacy source code using a terminal and sends it to the server. The input is a code image captured by the terminal's camera. The terminal converts the image to text format and sends that text data to the server.

[0513] Step 2:

[0514] The server uses a generative AI model to analyze the structure and dependencies of the received text data. The input is the scanned source code text data, and the output is the code's structural analysis data. The server identifies dependencies and analyzes the data flow and constraints within the program.

[0515] Step 3:

[0516] The server designs a cloud-native architecture based on the analysis results. The input is structural analysis data, and the output is a blueprint for the cloud-native architecture. The server generates modules and services suitable for the design framework.

[0517] Step 4:

[0518] The server translates legacy source code into a new programming language based on its designed cloud-native architecture. The input is legacy code and blueprints, and the output is the code translated into the new language. The server applies translation rules and reconstructs the code.

[0519] Step 5:

[0520] The server generates and runs automated verification cases for the converted code. The input is the code converted to the new language, and the output is the verification result. The server creates test cases using a generation AI model to verify that the code works according to specifications.

[0521] Step 6:

[0522] Users can view the results on their devices and visualize the progress and challenges until the migration is complete. Inputs are verification results and progress data obtained from the server, and output is a status report displayed on the device. Users can check the progress of the cloud migration through the device's interface.

[0523] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[0524] This invention relates to a system that enables companies to efficiently and effectively migrate their legacy systems to a modern cloud-native environment. This system incorporates an emotion engine that can optimize the system's responses and operations based on the user's emotional state.

[0525] To use the system, the user first sends legacy source code to the server via a terminal. The server analyzes the received source code, identifying its structure and dependencies. This allows the system to understand the overall architecture of the legacy code, enabling efficient processing in subsequent steps.

[0526] Next, the server uses generative AI technology to generate a cloud-native architecture design. This design has a microservices-based structure that is flexible and scalable, optimizing system performance. Based on the design, the server translates the original code into a new programming language, and generates and runs automated test cases to ensure the quality of the translated code.

[0527] Furthermore, the server uses natural language processing technology to analyze the business logic written in the original code and accurately applies that logic to the new code. It also proposes optimizations for optimizable parts of the business rules and implements them as needed.

[0528] A particularly noteworthy feature is the emotion engine built into the system. While the user is interacting with the system, the emotion engine determines their emotional state based on their voice, input speed, and the options they select. For example, if the system determines that the user is stressed, it adjusts the operation procedures and how information is presented to make the user more comfortable. Specifically, if the user is stressed by complicated operation steps, the emotion engine will provide simplified instructions to improve the user experience.

[0529] This system allows users to smoothly navigate the legacy system migration process, reducing emotional burden and improving work efficiency. Thus, the present invention demonstrates excellent effects not only from a technical standpoint but also from the perspective of improving the user experience.

[0530] The following describes the processing flow.

[0531] Step 1:

[0532] The user selects the legacy source code to migrate from their terminal and uploads it to the server. This operation is performed via the user interface, and the server stores the submitted files in a temporary storage location.

[0533] Step 2:

[0534] The server performs syntax analysis on the received code. Here, functions, variables, and dependencies within the code are identified, and a dependency map is generated. Based on this analysis information, the overall system structure is understood.

[0535] Step 3:

[0536] The server uses generative AI technology to automatically generate a cloud-native architecture design based on the analysis results. The design includes a microservices strategy and the specifications of the necessary APIs, which then leads to a rewrite of the code.

[0537] Step 4:

[0538] The server performs the code conversion process to the new programming language. Here, AI is used to efficiently convert the code into new code while preserving the functionality of the original code.

[0539] Step 5:

[0540] The server generates automated test cases for the newly converted code and runs these tests. The tests include unit tests and integration tests to ensure the code works correctly.

[0541] Step 6:

[0542] The server uses natural language processing techniques to analyze the business logic contained in the original code. Based on the results of this analysis, it applies the new code and verifies that the business logic functions correctly.

[0543] Step 7:

[0544] The emotion engine allows the server to monitor the user's emotional state. If stress or dissatisfaction is detected based on the user's response speed and interactions, the system automatically adjusts the operation flow and information presentation methods to optimize the user experience.

[0545] Step 8:

[0546] The server verifies that the converted code is deployable to the cloud environment. It provisions the necessary cloud resources, configures security settings, and finally notifies the user that the migration is complete.

[0547] (Example 2)

[0548] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[0549] In today's technological environment, while there is a need to adapt outdated program code to the cloud, the migration process presents significant challenges, requiring considerable time and effort. Furthermore, a lack of user-friendly support that considers the emotional state of users leads to decreased usability. Against this backdrop, there is a need for efficient and emotionally resonant methods to migrate outdated program code to the cloud environment.

[0550] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[0551] In this invention, the server includes means for receiving outdated program code via an information processing device and analyzing its structure and relationships; means for generating a design utilizing virtualization technology from the analyzed outdated program code; and means for determining the emotional state based on the user's actions and providing operational support. This enables the efficient adaptation of outdated program code to a cloud environment and improves the user's operational experience.

[0552] An "information processing device" refers to hardware that has the function of receiving, processing, and analyzing data, and is connected via a network.

[0553] "Outdated program code" refers to programs used in older technological environments and software structures that are not compatible with the latest technological systems.

[0554] "Structural and interrelationship analysis" refers to the process of breaking down program code and visualizing its basic structure and interactions.

[0555] "Designing with virtualization technology" refers to a method of constructing a system architecture that is flexible and efficiently usable by using computing abstraction.

[0556] "Determining emotional state based on user actions" refers to the process of analyzing interaction data such as speech recognition and input speed to estimate the emotions of the person performing the action.

[0557] "Operational support" refers to methods of guidance and suggestions provided in real time to support users' efficient activities.

[0558] This invention relates to an information processing system for adapting outdated program code to an environment utilizing modern virtualization technology. The user sends the outdated program code to a server using a terminal. The terminal is a general-purpose computer with an internet connection. The server analyzes the received program code using a parsing library to understand its structure and relationships. Specifically, the server can use ANTLR or similar parsing tools.

[0559] The server then uses a generative AI model to generate a design that leverages the new virtualization technology. During this process, prompts are input to the AI ​​model. For example, the prompt "Redesign the outdated accounting system for a virtualized environment" might be used. This allows the server to design a flexible and scalable system architecture.

[0560] Furthermore, based on user actions, the server determines the user's emotional state and provides operational support. This emotional determination utilizes speech recognition technology and input data analysis (e.g., Google Speech Recognition). When the user experiences stress, the server adjusts the UI and operational instructions to improve the user experience. This enables the entire system to efficiently migrate outdated program code to an emotionally sensitive virtualization environment.

[0561] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0562] Step 1:

[0563] The user sends outdated program code to the server using a terminal. The input here is a program file selected and uploaded by the user. The terminal transmits this file over the network and forwards it to the server. The output is the program code received by the server.

[0564] Step 2:

[0565] The server parses the received program code. Specifically, it uses a parsing library (e.g., ANTLR) to extract the code's structure and dependencies. The input here is the program code, and the output is the parsed structure information and dependency data. This data is used in the next step.

[0566] Step 3:

[0567] Based on the analyzed information, the server generates a design utilizing virtualization technology using a generative AI model. The input is the structural information and dependency data obtained in step 2. The prompt "Design an outdated system for a virtualized environment" is entered, and the AI ​​model generates a new architectural design. The output is a design proposal based on virtualization technology.

[0568] Step 4:

[0569] The server converts the old program code into a new information processing language based on the generated design. The inputs are the design proposal obtained in step 3 and the original program code. The server uses a code conversion tool to migrate this into the new language, thereby generating new program code as output.

[0570] Step 5:

[0571] The server automatically generates and executes verification items for the newly converted program code. The input is the new program code. The server generates verification items using an automated testing tool and executes them. This allows the test results to be obtained as output, confirming the quality of the code.

[0572] Step 6:

[0573] The server analyzes the operational logic of the outdated program code and accurately applies that logic to the new program. The input is the code portion containing the original operational logic. The output is the new program code reflecting the analyzed operational logic.

[0574] Step 7:

[0575] The server uses user interaction data, such as voice and input speed, to determine the user's emotional state and provide operational support. Input includes voice samples and keystroke data. An emotion engine analyzes this data and provides support, such as adjusting the UI, if the user is experiencing stress. The output is an optimized user experience.

[0576] (Application Example 2)

[0577] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[0578] Migrating legacy systems to a cloud-native environment is a significant burden due to their complex structure and dependencies. Furthermore, the emotional stress experienced by users during the migration process can reduce operational efficiency. Additionally, maintaining consistent quality while adapting to new technical specifications is not easy.

[0579] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means.

[0580] In this invention, the server includes means for analyzing software received from a legacy system and identifying its structure and dependencies, means for generating a cloud-native configuration from the analyzed software, and means for analyzing the user's emotional state and adjusting the user interface accordingly. This makes it possible to efficiently migrate legacy systems, reduce the emotional burden on users, and improve operational efficiency.

[0581] A "legacy system" is an information processing system built on older technologies and designs that continues to be used today.

[0582] "Cloud-native architecture" refers to a software design methodology optimized for cloud computing environments, including a microservices architecture that prioritizes flexibility and scalability.

[0583] "User emotional state" refers to the psychological state a user experiences while operating a system, including stress levels, satisfaction levels, and feelings of security.

[0584] "Means of adjusting the user interface" refers to a mechanism that dynamically changes the way the system is displayed and operated according to the user's emotional state, thereby improving the user's operational efficiency and comfort.

[0585] "Means for analyzing software and identifying its structure and dependencies" refers to techniques for analyzing the program code of legacy systems to reveal what components it is composed of and how those components relate to each other.

[0586] This system migrates legacy systems to a cloud-native environment and improves the user experience by analyzing user sentiment regarding their interactions.

[0587] The server first analyzes the software received from the legacy system to identify its structure and dependencies. This utilizes program analysis techniques to reveal the relationships between each module of the source code. Next, based on the analyzed information, it generates a cloud-native configuration. At this stage, it optimizes data flow and module interactions to design a more flexible and efficient system with new technical specifications.

[0588] To analyze the user's emotional state, an emotion engine is used to evaluate the voice tone and input speed obtained from the user interface. Specifically, speech recognition technology is used to convert voice input into text, and this text data is then analyzed by the emotion engine. The emotion engine has means to appropriately adjust the display and instructions on the operation screen based on the user's emotional state.

[0589] For example, if a user in the accounting department needs to quickly process a large amount of data during a busy period, the emotion engine will detect the user's stress level and automatically simplify the input interface, adjusting it to display only the necessary information, thereby reducing the user's workload.

[0590] An example of a prompt message would be, "We will analyze the user's voice track and automatically adjust the UI to simplify it if the voice tone becomes higher."

[0591] The software used includes a natural language processing engine for text analysis, an emotion engine for sentiment analysis, and a microservice configuration generator for cloud environment design. The servers are built to run on a cloud infrastructure to efficiently handle this data processing.

[0592] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[0593] Step 1:

[0594] The server receives source code from the legacy system. The source code of the legacy system is provided as input. The output is source code ready for analysis. This step converts the source code into a clean format to facilitate analysis.

[0595] Step 2:

[0596] The server analyzes the received source code and identifies its structure and dependencies. Legacy source code is used as input. The output generates information explicitly detailing the module structure and dependencies. Specifically, the dependencies between functions and classes within the code are stored in a database.

[0597] Step 3:

[0598] The server generates a cloud-native configuration based on the analyzed information. Identified structural and dependency data is used as input. The output is a new cloud-native design that prioritizes flexibility and efficiency. This step uses a microservices architecture to create the new blueprint.

[0599] Step 4:

[0600] The server converts legacy systems to new technical specifications based on a cloud-native configuration. Data from cloud-native design services is used as input. The output is code conforming to the new technical specifications. This conversion utilizes a generative AI model to optimize the code.

[0601] Step 5:

[0602] The server automatically generates and implements evaluation criteria based on the converted technical specifications. The input is the code of the new technical specifications. The output is quality assurance based on test results. Specifically, the server generates and executes test scripts to detect errors in the code.

[0603] Step 6:

[0604] The device collects the user's voice tone and input speed and sends them to the emotion engine. The inputs used are the user's voice data and input speed. The output is data representing the user's emotional state. This step involves acquiring real-time data from the device's microphone and keyboard.

[0605] Step 7:

[0606] The server adjusts the user interface based on the user's emotional state. Emotional state data is used as input. The output is an optimized user interface. Specifically, it minimizes the information displayed and makes it easier for the user to access the information they need most.

[0607] Step 8:

[0608] Users can continue operating comfortably through a well-tuned interface. The input is an optimized interface; the output is a stress-free operating experience. This improves operational efficiency and reduces the burden of work.

[0609] The specific processing unit 290 transmits the result of the specific processing to the headset terminal 314. In the headset terminal 314, the control unit 46A causes the speaker 240 and display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[0610] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0611] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and specific processing may also be performed by the headset terminal 314.

[0612] [Fourth Embodiment]

[0613] Figure 7 shows an example of the configuration of the data processing system 410 according to the fourth embodiment.

[0614] As shown in Figure 7, the data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

[0615] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0616] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a controlled object 443. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and controlled object 443 are also connected to the bus 52.

[0617] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

[0618] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the area around the user 20 (for example, an imaging range defined by a field of view equivalent to the width of a typical healthy person's field of vision).

[0619] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[0620] The controlled object 443 includes a display device, LEDs in the eyes, and motors that drive the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the robot 414's emotions can be expressed by controlling these motors. Furthermore, the robot 414's facial expressions can also be expressed by controlling the illumination state of the LEDs in its eyes.

[0621] Figure 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Figure 8, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[0622] The specific processing program 56 is an example of a "program" relating to the technology of this disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0623] The storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0624] In robot 414, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0625] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[0626] The system according to the present invention aims to efficiently migrate a company's legacy systems to a modern cloud-native environment. When implementing this system, each component works in cooperation with each other as follows, achieving a seamless migration process as a whole.

[0627] First, the user inputs the source code of the legacy system to be migrated into the system via a terminal. This source code is written in older languages ​​and frameworks. When the server receives this code, it first performs syntax analysis to understand the code's structure and dependencies. This analysis helps to understand the overall picture of the source code and identify inefficiencies and risks associated with the migration.

[0628] Based on the analysis results, the server utilizes generative AI technology to generate a cloud-native architecture design. The generated design is based on a microservices structure, achieving flexible scalability. At this stage, it is defined which parts will be adapted to the new environment and how.

[0629] As a concrete example, consider an old COBOL-based inventory management system. The business logic of this system is to automatically replenish inventory when it falls below a certain level. The server analyzes this logic and generates a design so that the same functionality can be applied in a new cloud environment.

[0630] Next, the server uses a conversion mechanism to convert the original COBOL code into a new programming language, such as Java or Python. This conversion not only replaces the language of the code but also optimizes the entire program to be runnable on the cloud.

[0631] Since the converted code cannot be tested directly, the server automatically generates and executes test cases. The tests mainly consist of unit tests and integration tests to verify that the entire system functions correctly. This automated testing method ensures high accuracy in the quality of the converted code and minimizes operational problems after migration.

[0632] Furthermore, the server utilizes natural language processing technology to appropriately analyze and apply the business logic within the legacy source code, ensuring that the new system meets the original business requirements. Optimization of the business logic is also performed as needed.

[0633] Through this series of processes, users can achieve advanced system migration with minimal need for specialized knowledge or technical support. Therefore, the embodiment of the present invention achieves reduced migration costs, mitigated migration risks, and improved operational flexibility.

[0634] The following describes the processing flow.

[0635] Step 1:

[0636] The user uploads the legacy source code to be migrated to the server via their terminal. The server saves the received code to storage and prepares it for analysis.

[0637] Step 2:

[0638] The server begins syntax analysis of the uploaded source code. This analysis helps to understand the overall structure of the code, functions, variables, and dependencies, and generates a dependency map.

[0639] Step 3:

[0640] The server uses generative AI technology to generate cloud-native architecture designs based on analysis results. For example, it designs microservice models and API interfaces for service partitioning.

[0641] Step 4:

[0642] The server translates the legacy source code into a new programming language of its choice, according to the generated design. The translation ensures that each function and data structure functions correctly in the new language.

[0643] Step 5:

[0644] The server uses AI to generate automated test cases for the newly converted code and runs these tests. These tests include unit tests and integration tests to verify the quality and accuracy of the code.

[0645] Step 6:

[0646] The server uses natural language processing to extract the business logic contained in the original code and verify that it is correctly reflected in the new code. If necessary, it suggests optimizations to the business logic.

[0647] Step 7:

[0648] As a final check, the server verifies that the new system can be deployed to the cloud environment. This includes checking resource settings and security policies.

[0649] Step 8:

[0650] The server sends a notification to the user that the migration is complete and finally verifies that the migrated system meets the required performance and functional requirements.

[0651] (Example 1)

[0652] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[0653] Many corporate information processing environments still operate legacy systems built on outdated technological foundations, often unable to adapt to new technologies. This makes migrating to the latest distributed processing infrastructure difficult, resulting in increasing operational costs and technical debt. Furthermore, maintaining and optimizing business rules during the conversion process is crucial, necessitating complete automation.

[0654] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0655] In this invention, the server includes means for receiving legacy information and analyzing its structure and dependencies, means for generating a distributed processing platform design from the analyzed legacy information, and means for converting the legacy information into a new programming syntax based on the generated distributed processing platform design. This enables a smooth transition of legacy systems to the latest technological environment and reduces operational costs.

[0656] "Legacy information" refers to existing information systems built on older technological foundations that are difficult to adapt to the latest technological environment.

[0657] "Structure" refers to the internal organization of information or a system, as well as the relationships between its elements.

[0658] "Dependency" refers to a state in which elements of different systems or structures are mutually dependent on each other.

[0659] "Means of analysis" refers to techniques and methods for breaking down information and understanding its structure and characteristics.

[0660] A "distributed processing infrastructure" refers to a structure or technology that distributes information processing across multiple independent computers.

[0661] "Means of generating a design" refers to methods and techniques for creating a system design or plan based on a specific purpose.

[0662] "Programming syntax" refers to the format and rules of code used to specify behavior in a particular programming language.

[0663] "Evaluation criteria" refers to standards or rules established to verify the operation and performance of new information or systems.

[0664] "Business rules" refer to regulations that define the conditions and methods for business processes executed within an organization or system.

[0665] "Natural language processing technology" refers to the techniques and methods used to understand and process human language using computers.

[0666] This invention provides a system for migrating an enterprise's outdated information processing system to a state-of-the-art distributed processing infrastructure environment. Specific embodiments thereof are described below.

[0667] Users input foundational information from the company's existing information systems into the server via a terminal. This foundational information is written using outdated programming techniques and frameworks.

[0668] The server uses a syntax analysis tool (e.g., ANTLR) to parse the input information. This clarifies the structure and dependencies of the information, identifying inefficiencies and risks associated with the migration.

[0669] Based on the analysis results, the server utilizes a generative AI model (e.g., OpenAI's GPT) to generate a new distributed processing platform design. This design is particularly adapted to cloud services (e.g., AWS and GCP) and is based on a microservices architecture.

[0670] Next, the server uses a conversion engine to convert the original information into a new programming syntax, such as Java or Python. This conversion not only replaces the syntax but also optimizes it to suit the new platform.

[0671] Subsequently, to verify the code's operation, the server automatically generates and executes evaluation criteria. These tests primarily consist of unit tests and integration tests, confirming the proper functioning of the entire system.

[0672] Furthermore, the server uses natural language processing technology to appropriately analyze and apply the business rules of the underlying information, and verifies that the new information meets the original business requirements. If necessary, it also optimizes the business rules.

[0673] As a concrete example, consider a COBOL-based inventory management system. One of the system's operational rules is to automatically replenish inventory when it falls below a certain level. The server analyzes this rule and configures the system to function similarly on the new distributed infrastructure.

[0674] For example, enter the following prompt:

[0675] "Analyze this COBOL-based inventory management system and generate Java code adapted for a cloud-native environment."

[0676] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0677] Step 1:

[0678] The user inputs foundational information from the legacy system into the server via a terminal. This information is written in an older programming language (e.g., COBOL). This input information forms the basis for processing.

[0679] Step 2:

[0680] The server performs syntax analysis based on the input information. At this stage, a syntax analysis tool (e.g., ANTLR) is used to analyze the code structure and dependencies. The output is the internal structure of the code and a dependency map.

[0681] Step 3:

[0682] Based on the analysis results, the server generates a distributed processing infrastructure design using a generated AI model. It receives the analysis results as input and outputs a design document for a microservice architecture suitable for a cloud environment.

[0683] Step 4:

[0684] The server runs a conversion engine that translates the original programming language into a new language (e.g., Java, Python). This process optimizes the code based on the design document and outputs the converted program.

[0685] Step 5:

[0686] The converted code enters a testing stage to verify that it works correctly. The server automatically generates unit and integration tests and runs them using testing tools. Based on the test results, the code is evaluated to see if it functions properly.

[0687] Step 6:

[0688] Furthermore, the server uses natural language processing technology to analyze the business rules contained in the underlying information. The acquired business rules are applied to the converted information to verify whether the required business functions are maintained. The output is the result of the business rule compliance verification.

[0689] (Application Example 1)

[0690] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[0691] In recent years, legacy systems used within companies have become unable to keep up with the rapidly changing business environment, resulting in a significant burden for their maintenance and operation. Furthermore, migrating to a cloud-native environment requires technical knowledge and effort, posing a major obstacle, especially for small and medium-sized enterprises. Moreover, managing the progress of the migration process and detecting problems early is difficult, leading to project delays and increased costs. Therefore, a system capable of efficient and real-time migration is necessary.

[0692] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0693] In this invention, the server includes means for receiving legacy source code and analyzing its structure and dependencies, means for generating a cloud-native architecture from the analyzed legacy source code, and means for scanning the source code using a mobile terminal or wireless communication device and visualizing the analysis results. This enables users to smoothly proceed with the migration process of legacy systems to the cloud, and to understand the situation and solve problems in real time.

[0694] "Legacy source code" refers to older program code that a company or organization has used for a long period of time, and is usually written using older programming languages ​​or technologies.

[0695] "Structural and dependency analysis" is the process of identifying and understanding the internal structure of program code and its interdependencies with other components.

[0696] A "cloud-native architecture" is a design optimized for cloud environments, offering flexibility and scalability, and is often based on a microservices architecture.

[0697] "Programming language conversion" is the process of translating specific program code into a different programming language so that it can run in a new environment.

[0698] An "automatic verification case" is a test scenario that is automatically generated to verify the accuracy and functionality of the converted program code.

[0699] "Business rules" are the business logic and rules defined within a legacy system that need to be reproduced in the new system.

[0700] "Mobile devices or wireless communication devices" refer to electronic devices that use wireless communication technology to process information, including smartphones and smart glasses.

[0701] "Visualization of analysis results" is the process of displaying the analyzed data and progress in a format that is easy for users to understand.

[0702] An "external computing environment" refers to an environment used for performing computational processing using cloud services or remote servers.

[0703] The system for realizing this invention provides a series of processes for efficiently migrating to the cloud. The server receives legacy source code scanned by a user's mobile device. This device is a common portable information processing device, such as a smartphone or smart glasses.

[0704] First, the server uses a generative AI model to analyze the structure and dependencies of the legacy source code in detail. Based on the data obtained from this analysis, the server designs an optimal cloud-native architecture. This architecture is flexible and scalable, and is primarily based on a microservices architecture.

[0705] Next, the server translates the legacy source code into a new programming language based on the analysis results. This translation is not a direct substitution of code between languages, but includes optimizations suitable for the cloud environment. The server efficiently performs this process by utilizing external computing environments, such as Google Cloud Platform or Amazon Web Services.

[0706] The newly converted source code is verified for functionality and accuracy using automatically generated validation cases. This ensures high quality and confirms that the migrated system operates correctly. Users can visualize and understand this progress and any remaining issues via their mobile devices.

[0707] As a concrete example, users can use smart glasses during meetings to monitor the status of the cloud migration process and participate in real-time discussions. An example of a prompt is, "Analyze the code of this COBOL-based inventory management system and generate a cloud-native design based on a microservices architecture." This prompt allows the generating AI model to support the cloud migration quickly and effectively.

[0708] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0709] Step 1:

[0710] The user scans legacy source code using a terminal and sends it to the server. The input is a code image captured by the terminal's camera. The terminal converts the image to text format and sends that text data to the server.

[0711] Step 2:

[0712] The server uses a generative AI model to analyze the structure and dependencies of the received text data. The input is the scanned source code text data, and the output is the code's structural analysis data. The server identifies dependencies and analyzes the data flow and constraints within the program.

[0713] Step 3:

[0714] The server designs a cloud-native architecture based on the analysis results. The input is structural analysis data, and the output is a blueprint for the cloud-native architecture. The server generates modules and services suitable for the design framework.

[0715] Step 4:

[0716] The server translates legacy source code into a new programming language based on its designed cloud-native architecture. The input is legacy code and blueprints, and the output is the code translated into the new language. The server applies translation rules and reconstructs the code.

[0717] Step 5:

[0718] The server generates and runs automated verification cases for the converted code. The input is the code converted to the new language, and the output is the verification result. The server creates test cases using a generation AI model to verify that the code works according to specifications.

[0719] Step 6:

[0720] Users can view the results on their devices and visualize the progress and challenges until the migration is complete. Inputs are verification results and progress data obtained from the server, and output is a status report displayed on the device. Users can check the progress of the cloud migration through the device's interface.

[0721] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[0722] This invention relates to a system that enables companies to efficiently and effectively migrate their legacy systems to a modern cloud-native environment. This system incorporates an emotion engine that can optimize the system's responses and operations based on the user's emotional state.

[0723] To use the system, the user first sends legacy source code to the server via a terminal. The server analyzes the received source code, identifying its structure and dependencies. This allows the system to understand the overall architecture of the legacy code, enabling efficient processing in subsequent steps.

[0724] Next, the server uses generative AI technology to generate a cloud-native architecture design. This design has a microservices-based structure that is flexible and scalable, optimizing system performance. Based on the design, the server translates the original code into a new programming language, and generates and runs automated test cases to ensure the quality of the translated code.

[0725] Furthermore, the server uses natural language processing technology to analyze the business logic written in the original code and accurately applies that logic to the new code. It also proposes optimizations for optimizable parts of the business rules and implements them as needed.

[0726] A particularly noteworthy feature is the emotion engine built into the system. While the user is interacting with the system, the emotion engine determines their emotional state based on their voice, input speed, and the options they select. For example, if the system determines that the user is stressed, it adjusts the operation procedures and how information is presented to make the user more comfortable. Specifically, if the user is stressed by complicated operation steps, the emotion engine will provide simplified instructions to improve the user experience.

[0727] This system allows users to smoothly navigate the legacy system migration process, reducing emotional burden and improving work efficiency. Thus, the present invention demonstrates excellent effects not only from a technical standpoint but also from the perspective of improving the user experience.

[0728] The following describes the processing flow.

[0729] Step 1:

[0730] The user selects the legacy source code to migrate from their terminal and uploads it to the server. This operation is performed via the user interface, and the server stores the submitted files in a temporary storage location.

[0731] Step 2:

[0732] The server performs syntax analysis on the received code. Here, functions, variables, and dependencies within the code are identified, and a dependency map is generated. Based on this analysis information, the overall system structure is understood.

[0733] Step 3:

[0734] The server uses generative AI technology to automatically generate a cloud-native architecture design based on the analysis results. The design includes a microservices strategy and the specifications of the necessary APIs, which then leads to a rewrite of the code.

[0735] Step 4:

[0736] The server performs the code conversion process to the new programming language. Here, AI is used to efficiently convert the code into new code while preserving the functionality of the original code.

[0737] Step 5:

[0738] The server generates automated test cases for the newly converted code and runs these tests. The tests include unit tests and integration tests to ensure the code works correctly.

[0739] Step 6:

[0740] The server uses natural language processing techniques to analyze the business logic contained in the original code. Based on the results of this analysis, it applies the new code and verifies that the business logic functions correctly.

[0741] Step 7:

[0742] The emotion engine allows the server to monitor the user's emotional state. If stress or dissatisfaction is detected based on the user's response speed and interactions, the system automatically adjusts the operation flow and information presentation methods to optimize the user experience.

[0743] Step 8:

[0744] The server verifies that the converted code is deployable to the cloud environment. It provisions the necessary cloud resources, configures security settings, and finally notifies the user that the migration is complete.

[0745] (Example 2)

[0746] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[0747] In today's technological environment, while there is a need to adapt outdated program code to the cloud, the migration process presents significant challenges, requiring considerable time and effort. Furthermore, a lack of user-friendly support that considers the emotional state of users leads to decreased usability. Against this backdrop, there is a need for efficient and emotionally resonant methods to migrate outdated program code to the cloud environment.

[0748] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[0749] In this invention, the server includes means for receiving outdated program code via an information processing device and analyzing its structure and relationships; means for generating a design utilizing virtualization technology from the analyzed outdated program code; and means for determining the emotional state based on the user's actions and providing operational support. This enables the efficient adaptation of outdated program code to a cloud environment and improves the user's operational experience.

[0750] An "information processing device" refers to hardware that has the function of receiving, processing, and analyzing data, and is connected via a network.

[0751] "Outdated program code" refers to programs used in older technological environments and software structures that are not compatible with the latest technological systems.

[0752] "Structural and interrelationship analysis" refers to the process of breaking down program code and visualizing its basic structure and interactions.

[0753] "Designing with virtualization technology" refers to a method of constructing a system architecture that is flexible and efficiently usable by using computing abstraction.

[0754] "Determining emotional state based on user actions" refers to the process of analyzing interaction data such as speech recognition and input speed to estimate the emotions of the person performing the action.

[0755] "Operational support" refers to methods of guidance and suggestions provided in real time to support users' efficient activities.

[0756] This invention relates to an information processing system for adapting outdated program code to an environment utilizing modern virtualization technology. The user sends the outdated program code to a server using a terminal. The terminal is a general-purpose computer with an internet connection. The server analyzes the received program code using a parsing library to understand its structure and relationships. Specifically, the server can use ANTLR or similar parsing tools.

[0757] The server then uses a generative AI model to generate a design that leverages the new virtualization technology. During this process, prompts are input to the AI ​​model. For example, the prompt "Redesign the outdated accounting system for a virtualized environment" might be used. This allows the server to design a flexible and scalable system architecture.

[0758] Furthermore, based on user actions, the server determines the user's emotional state and provides operational support. This emotional determination utilizes speech recognition technology and input data analysis (e.g., Google Speech Recognition). When the user experiences stress, the server adjusts the UI and operational instructions to improve the user experience. This enables the entire system to efficiently migrate outdated program code to an emotionally sensitive virtualization environment.

[0759] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0760] Step 1:

[0761] The user sends outdated program code to the server using a terminal. The input here is a program file selected and uploaded by the user. The terminal transmits this file over the network and forwards it to the server. The output is the program code received by the server.

[0762] Step 2:

[0763] The server parses the received program code. Specifically, it uses a parsing library (e.g., ANTLR) to extract the code's structure and dependencies. The input here is the program code, and the output is the parsed structure information and dependency data. This data is used in the next step.

[0764] Step 3:

[0765] Based on the analyzed information, the server generates a design utilizing virtualization technology using a generative AI model. The input is the structural information and dependency data obtained in step 2. The prompt "Design an outdated system for a virtualized environment" is entered, and the AI ​​model generates a new architectural design. The output is a design proposal based on virtualization technology.

[0766] Step 4:

[0767] The server converts the old program code into a new information processing language based on the generated design. The inputs are the design proposal obtained in step 3 and the original program code. The server uses a code conversion tool to migrate this into the new language, thereby generating new program code as output.

[0768] Step 5:

[0769] The server automatically generates and executes verification items for the newly converted program code. The input is the new program code. The server generates verification items using an automated testing tool and executes them. This allows the test results to be obtained as output, confirming the quality of the code.

[0770] Step 6:

[0771] The server analyzes the operational logic of the outdated program code and accurately applies that logic to the new program. The input is the code portion containing the original operational logic. The output is the new program code reflecting the analyzed operational logic.

[0772] Step 7:

[0773] The server uses user interaction data, such as voice and input speed, to determine the user's emotional state and provide operational support. Input includes voice samples and keystroke data. An emotion engine analyzes this data and provides support, such as adjusting the UI, if the user is experiencing stress. The output is an optimized user experience.

[0774] (Application Example 2)

[0775] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[0776] Migrating legacy systems to a cloud-native environment is a significant burden due to their complex structure and dependencies. Furthermore, the emotional stress experienced by users during the migration process can reduce operational efficiency. Additionally, maintaining consistent quality while adapting to new technical specifications is not easy.

[0777] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means.

[0778] In this invention, the server includes means for analyzing software received from a legacy system and identifying its structure and dependencies, means for generating a cloud-native configuration from the analyzed software, and means for analyzing the user's emotional state and adjusting the user interface accordingly. This makes it possible to efficiently migrate legacy systems, reduce the emotional burden on users, and improve operational efficiency.

[0779] A "legacy system" is an information processing system built on older technologies and designs that continues to be used today.

[0780] "Cloud-native architecture" refers to a software design methodology optimized for cloud computing environments, including a microservices architecture that prioritizes flexibility and scalability.

[0781] "User emotional state" refers to the psychological state a user experiences while operating a system, including stress levels, satisfaction levels, and feelings of security.

[0782] "Means of adjusting the user interface" refers to a mechanism that dynamically changes the way the system is displayed and operated according to the user's emotional state, thereby improving the user's operational efficiency and comfort.

[0783] "Means for analyzing software and identifying its structure and dependencies" refers to techniques for analyzing the program code of legacy systems to reveal what components it is composed of and how those components relate to each other.

[0784] This system migrates legacy systems to a cloud-native environment and improves the user experience by analyzing user sentiment regarding their interactions.

[0785] The server first analyzes the software received from the legacy system to identify its structure and dependencies. This utilizes program analysis techniques to reveal the relationships between each module of the source code. Next, based on the analyzed information, it generates a cloud-native configuration. At this stage, it optimizes data flow and module interactions to design a more flexible and efficient system with new technical specifications.

[0786] To analyze the user's emotional state, an emotion engine is used to evaluate the voice tone and input speed obtained from the user interface. Specifically, speech recognition technology is used to convert voice input into text, and this text data is then analyzed by the emotion engine. The emotion engine has means to appropriately adjust the display and instructions on the operation screen based on the user's emotional state.

[0787] For example, if a user in the accounting department needs to quickly process a large amount of data during a busy period, the emotion engine will detect the user's stress level and automatically simplify the input interface, adjusting it to display only the necessary information, thereby reducing the user's workload.

[0788] An example of a prompt message would be, "We will analyze the user's voice track and automatically adjust the UI to simplify it if the voice tone becomes higher."

[0789] The software used includes a natural language processing engine for text analysis, an emotion engine for sentiment analysis, and a microservice configuration generator for cloud environment design. The servers are built to run on a cloud infrastructure to efficiently handle this data processing.

[0790] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[0791] Step 1:

[0792] The server receives source code from the legacy system. The source code of the legacy system is provided as input. The output is source code ready for analysis. This step converts the source code into a clean format to facilitate analysis.

[0793] Step 2:

[0794] The server analyzes the received source code and identifies its structure and dependencies. Legacy source code is used as input. The output generates information explicitly detailing the module structure and dependencies. Specifically, the dependencies between functions and classes within the code are stored in a database.

[0795] Step 3:

[0796] The server generates a cloud-native configuration based on the analyzed information. Identified structural and dependency data is used as input. The output is a new cloud-native design that prioritizes flexibility and efficiency. This step uses a microservices architecture to create the new blueprint.

[0797] Step 4:

[0798] The server converts legacy systems to new technical specifications based on a cloud-native configuration. Data from cloud-native design services is used as input. The output is code conforming to the new technical specifications. This conversion utilizes a generative AI model to optimize the code.

[0799] Step 5:

[0800] The server automatically generates and implements evaluation criteria based on the converted technical specifications. The input is the code of the new technical specifications. The output is quality assurance based on test results. Specifically, the server generates and executes test scripts to detect errors in the code.

[0801] Step 6:

[0802] The device collects the user's voice tone and input speed and sends them to the emotion engine. The inputs used are the user's voice data and input speed. The output is data representing the user's emotional state. This step involves acquiring real-time data from the device's microphone and keyboard.

[0803] Step 7:

[0804] The server adjusts the user interface based on the user's emotional state. Emotional state data is used as input. The output is an optimized user interface. Specifically, it minimizes the information displayed and makes it easier for the user to access the information they need most.

[0805] Step 8:

[0806] Users can continue operating comfortably through a well-tuned interface. The input is an optimized interface; the output is a stress-free operating experience. This improves operational efficiency and reduces the burden of work.

[0807] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the controlled object 443 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[0808] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0809] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the robot 414.

[0810] Furthermore, the emotion identification model 59, acting as an emotion engine, may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to a specific mapping, which is an emotion map (see Figure 9). Similarly, the emotion identification model 59 may also determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[0811] Figure 9 shows an emotion map 400 in which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. The closer to the center of the concentric circles, the more primitive the emotions are located. Further out of the concentric circles, emotions representing states and actions arising from mental states are located. Emotion is a concept that includes feelings and mental states. On the left side of the concentric circles, emotions that are generally generated from reactions occurring in the brain are located. On the right side of the concentric circles, emotions that are generally induced by situational judgment are located. Above and below the concentric circles, emotions that are generally generated from reactions occurring in the brain and induced by situational judgment are located. In addition, the emotion of "pleasure" is located on the upper side of the concentric circles, and the emotion of "displeasure" is located on the lower side. Thus, in the emotion map 400, multiple emotions are mapped based on the structure in which emotions arise, and emotions that are likely to occur simultaneously are mapped close together.

[0812] These emotions are distributed at the 3 o'clock position on the Emotion Map 400, and usually fluctuate between feelings of security and anxiety. In the right half of the Emotion Map 400, situational awareness takes precedence over internal feelings, resulting in a calm impression.

[0813] The inside of the Emotion Map 400 represents inner thoughts, while the outside represents actions. Therefore, the further you go from the outside of the Emotion Map 400, the more visible (expressed in actions) your emotions become.

[0814] Here, human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. Similarly, in robots, cars, motorcycles, etc., emotions can be created based on various balances, such as posture and battery level. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. The emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on a system for analyzing brain physiological signals of speech emotion recognition and emotion, Tokushima University, doctoral dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map contains emotions belonging to a region called "response," where sensation is dominant. The right half of the emotion map contains emotions belonging to a region called "situation," where situational awareness is dominant.

[0815] The emotion map defines two emotions that promote learning. One is the emotion around the middle of the negative "repentance" and "reflection" on the situation side. In other words, it is when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is the emotion around the positive "desire" on the reaction side. In other words, it is when the robot has positive feelings such as "I want more" or "I want to know more."

[0816] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​representing each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple training data sets, which are combinations of user input and emotion values ​​representing each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions located close together have similar values, as shown in the emotion map 900 in Figure 10. Figure 10 shows an example where multiple emotions such as "reassured," "calm," and "confident" have similar emotion values.

[0817] The above description primarily focuses on the functions of the data processing device 12 in relation to this disclosure. However, the system related to this disclosure is not necessarily implemented on a server. The system related to this disclosure may be implemented as a general information processing system. This disclosure may be implemented, for example, as a software program that runs on a personal computer or as an application that runs on a smartphone. The method related to this disclosure may be provided to users in SaaS (Software as a Service) format.

[0818] In the above embodiment, an example was given in which a specific process is performed by a single computer 22. However, the technology of this disclosure is not limited thereto, and a distributed processing of the specific process may be performed by multiple computers, including computer 22. For example, a data generation model 58 may be provided in an external device of the data processing device 12, and the external device may generate data according to the input data.

[0819] In the above embodiment, an example was given in which the specific processing program 56 is stored in the storage 32, but the technology of this disclosure is not limited thereto. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-temporary storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-temporary storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes specific processing according to the specific processing program 56.

[0820] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[0821] Furthermore, it is not necessary to store the entirety of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store the entirety of the specific processing program 56 in the storage 32; it is acceptable to store only a portion of the specific processing program 56.

[0822] The following types of processors can be used as hardware resources to perform specific processing. Examples of processors include a CPU, a general-purpose processor that functions as a hardware resource to perform specific processing by executing software, i.e., a program. Other examples of processors include dedicated electrical circuits, such as FPGAs (Field-Programmable Gate Arrays), PLDs (Programmable Logic Devices), or ASICs (Application Specific Integrated Circuits), which have circuit configurations specifically designed to perform specific processing. All of these processors have built-in or connected memory, and all of them perform specific processing by using memory.

[0823] The hardware resource that performs a specific process may consist of one of these various processors, or it may consist of a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Alternatively, the hardware resource that performs a specific process may consist of a single processor.

[0824] Examples of configurations using a single processor include, firstly, a configuration in which one or more CPUs and software are combined to form a single processor, and this processor functions as a hardware resource that performs a specific process. Secondly, there is a configuration using a processor that realizes the functions of the entire system, including multiple hardware resources that perform a specific process, on a single IC chip, as exemplified by SoCs (System-on-a-chip). In this way, a specific process is realized using one or more of the above types of processors as hardware resources.

[0825] Furthermore, the hardware structure of these various processors can more specifically utilize electrical circuits that combine circuit elements such as semiconductor devices. Also, the specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps can be deleted, new steps added, or the processing order rearranged, as long as it does not deviate from the main purpose.

[0826] The descriptions and illustrations presented above are detailed explanations of the technical aspects of this disclosure and are merely examples of the technical aspects. For example, the above descriptions of the structure, function, operation, and effect are examples of the structure, function, operation, and effect of the technical aspects of this disclosure. Therefore, it goes without saying that you may delete unnecessary parts, add new elements, or replace elements in the descriptions and illustrations presented above, as long as you do not deviate from the essence of the technical aspects of this disclosure. Furthermore, in order to avoid confusion and facilitate understanding of the technical aspects of this disclosure, explanations of common technical knowledge and the like that do not require special explanation to enable the implementation of the technical aspects of this disclosure have been omitted from the descriptions and illustrations presented above.

[0827] All documents, patent applications, and technical standards described herein are incorporated by reference to the same extent as if each individual document, patent application, and technical standard were specifically and individually noted to be incorporated by reference.

[0828] The following is further disclosed regarding the embodiments described above.

[0829] (Claim 1)

[0830] A means for receiving legacy source code and analyzing its structure and dependencies,

[0831] A method for generating cloud-native architecture designs from analyzed legacy source code,

[0832] A means of converting legacy source code to a new programming language based on the generated cloud-native design,

[0833] A means for automatically generating and executing test cases for the new source code after conversion,

[0834] A means to analyze the business logic within legacy source code and apply that logic to new source code,

[0835] A system that includes this.

[0836] (Claim 2)

[0837] The system according to claim 1, comprising means for verifying that the new source code can be deployed to a cloud service environment based on the generated cloud-native design.

[0838] (Claim 3)

[0839] The system according to claim 1, comprising means for extracting business rules from legacy source code using natural language processing technology and proposing and implementing optimizable parts.

[0840] "Example 1"

[0841] (Claim 1)

[0842] A means for receiving legacy information and analyzing its structure and dependencies,

[0843] A means for generating a distributed processing infrastructure design from analyzed legacy information,

[0844] A means of converting legacy information into new programming syntax based on the generated distributed processing infrastructure design,

[0845] A means for automatically generating and implementing evaluation criteria for the new information after conversion,

[0846] A means of analyzing business rules within legacy information and applying those rules to new information,

[0847] A system that includes this.

[0848] (Claim 2)

[0849] The system according to claim 1, comprising means for verifying that new information can be implemented in a shared resource environment based on the generated distributed processing infrastructure design.

[0850] (Claim 3)

[0851] The system according to claim 1, comprising means for extracting business rules from legacy information using natural language processing technology and proposing and implementing optimizable parts.

[0852] "Application Example 1"

[0853] (Claim 1)

[0854] A means for receiving legacy source code and analyzing its structure and dependencies,

[0855] A means of generating a cloud-native architecture from analyzed legacy source code,

[0856] A means of converting the source code of a legacy system into a new programming language based on the generated cloud-native design,

[0857] A means for creating and executing automated verification cases for the new source code after conversion,

[0858] A means of analyzing business rules within legacy source code and applying those rules to new source code,

[0859] A means for scanning source code using a mobile device or wireless communication device and visualizing the results of the analysis,

[0860] A means of monitoring the conversion status from legacy systems in real time using an external computing environment and presenting progress and issues,

[0861] A system that includes this.

[0862] (Claim 2)

[0863] The system according to claim 1, comprising means for verifying that the new source code can be deployed to a virtual computing resource environment based on the generated cloud-native design.

[0864] (Claim 3)

[0865] The system according to claim 1, comprising means for extracting business rules from legacy source code using natural language processing technology and proposing and implementing optimizable parts.

[0866] "Example 2 of combining an emotion engine"

[0867] (Claim 1)

[0868] A means for receiving outdated program code via an information processing device and analyzing its structure and relationships,

[0869] A means of generating a design using virtualization technology from analyzed outdated program code,

[0870] A means of converting outdated program code into a new information processing language based on the generated design,

[0871] A means for automatically generating and performing verification items for the new program after conversion,

[0872] A means of analyzing the operational logic within outdated program code and applying that logic to a new program,

[0873] A means of determining the user's emotional state based on their actions and providing operational support,

[0874] A system that includes this.

[0875] (Claim 2)

[0876] The system according to claim 1, comprising means for verifying that the new program can be deployed to a virtual space service environment based on the generated design.

[0877] (Claim 3)

[0878] The system according to claim 1, comprising means for extracting business rules within outdated program code using natural language processing technology, and proposing and implementing optimizable parts.

[0879] "Application example 2 when combining with an emotional engine"

[0880] (Claim 1)

[0881] A means for analyzing software received from a legacy system and identifying its structure and dependencies,

[0882] A means of generating a cloud-native configuration from analyzed software,

[0883] A means of converting legacy systems to new technical specifications based on the generated cloud-native configuration,

[0884] A means for automatically generating and implementing evaluation criteria based on the new technical specifications after conversion,

[0885] A means of analyzing business logic within legacy systems and applying it to new technical specifications,

[0886] A means of analyzing the user's emotional state and adjusting the user interface based on that,

[0887] A system that includes this.

[0888] (Claim 2)

[0889] The system according to claim 1, comprising means for verifying that the new technical specifications can be deployed to an online service environment based on the generated cloud-native configuration.

[0890] (Claim 3)

[0891] The system according to claim 1, comprising means for extracting business rules within a legacy system using natural language processing technology, and proposing and implementing parts that can be optimized. [Explanation of symbols]

[0892] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Devices 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robots< / url:> < / url:> < / url:> < / url:>

Claims

1. A means for receiving legacy source code and analyzing its structure and dependencies, A means of generating a cloud-native architecture from analyzed legacy source code, A means of converting the source code of a legacy system into a new programming language based on the generated cloud-native design, A means for creating and executing automated verification cases for the new source code after conversion, A means of analyzing business rules within legacy source code and applying those rules to new source code, A means for scanning source code using a mobile device or wireless communication device and visualizing the results of the analysis, A means of monitoring the conversion status from legacy systems in real time using an external computing environment and presenting progress and issues, A system that includes this.

2. The system according to claim 1, further comprising means for verifying that the new source code can be deployed to a virtual computing resource environment based on the generated cloud-native design.

3. The system according to claim 1, comprising means for extracting business rules from legacy source code using natural language processing technology and proposing and implementing optimizable parts.

Images