System

Abstract

A system is provided.SOLUTION: A system comprising: means for utilizing generated artificial intelligence to analyze a program code and a network configuration; means for transmitting an analysis result onto a cloud to obtain a code structure to be optimized; and means for automatically updating the program code based on the obtained optimized code structure.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

[0002] Patent document 1 discloses a persona chatbot control method performed by at least one processor, the method including the steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to a description of the 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] Japanese Patent Publication No. 2022-180282 Summary of the Invention [Problem to be solved by the invention]

[0004] In today's IT industry, maintaining and operating older systems is becoming increasingly difficult. These systems are becoming increasingly complex, accumulating technical debt and making them difficult for new engineers to understand. Furthermore, a significant shortage of IT personnel is predicted by 2025, which will have a serious impact on the reliability of system operation and maintenance. This situation increases the risk of system failure and may ultimately result in economic losses. Therefore, there is a need for a method to automatically analyze and optimize the code and network configuration of older systems to enable efficient and safe operation. [Means for solving the problem]

[0005] The present invention provides a system that uses generated AI to analyze and optimize code and network configurations. Specifically, a plugin installed in the target system environment performs a detailed analysis of the system's internal program code and network configuration. The analysis results are then sent to a cloud-based AI service to obtain the code structure to be optimized. The program code is then automatically updated based on the obtained optimized code structure, stabilizing system operation. The system also visualizes the program code analysis results as class diagrams and interface specifications, and provides a means for further modifying the optimized code based on user feedback. This addresses the problem of a shortage of IT personnel and enables efficient maintenance and operation of legacy systems.

[0006] "Generated AI" refers to an AI model trained on a specific algorithm or dataset that is capable of self-sufficiently analyzing and optimizing for a given task.

[0007] "Program code" is a collection of computer-executable instructions, and is text data written to achieve specific operations or functions.

[0008] A "network configuration" is a collection of connection configurations and setting information that enable multiple computers and devices to communicate and exchange data with each other.

[0009] "Analyzing" means examining the target program code or network configuration in detail, classifying and breaking it down to understand its internal structure and operation.

[0010] "Sending to the cloud" means sending data collected or generated in a local environment to a remote server or service via the Internet.

[0011] The "code structure to be optimized" refers to a new design or layout for improving the current program code in order to improve the system's operational efficiency and maintainability.

[0012] A "class diagram" is a diagram in object-oriented design that visually represents the relationships between classes, their attributes, and their methods.

[0013] An "interface specification" is a specification of protocols or procedures for defining the interaction between different systems or components.

[0014] "Feedback" refers to opinions and evaluations provided by system users that are reflected in improving and optimizing the system. [Brief explanation of the drawings]

[0015] [Figure 1] 1 is a conceptual diagram showing an example of the configuration of a data processing system according to a first embodiment. [Figure 2] 1 is a conceptual diagram showing an example of main functions of a data processing device and a smart device according to a first embodiment. [Figure 3] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a second embodiment. [Figure 4] FIG. 10 is a conceptual diagram showing an example of main functions of a data processing device and smart glasses according to a second embodiment. [Figure 5] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a third embodiment. [Figure 6] FIG. 11 is a conceptual diagram showing an example of main functions of a data processing device and a headset-type terminal according to a third embodiment. [Figure 7] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a fourth embodiment. [Figure 8] FIG. 10 is a conceptual diagram showing an example of main functions of a data processing device and a robot according to a fourth embodiment. [Figure 9] 1 shows an emotion map onto which multiple emotions are mapped. [Figure 10] 1 shows an emotion map onto which multiple emotions are mapped. [Figure 11] FIG. 3 is a sequence diagram showing a processing flow of the data processing system according to the first embodiment. [Figure 12] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 1. [Figure 13] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system according to the second embodiment when an emotion engine is combined. [Figure 14] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 2 when an emotion engine is combined. DETAILED DESCRIPTION OF THE INVENTION

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

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

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

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

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

[0021] In the following embodiments, a communication I / F (Interface) with a symbol is an interface including a communication processor, an antenna, etc. The communication I / F controls communication between multiple computers. Examples of communication standards applied to the communication I / F include wireless communication standards including 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), Bluetooth (registered trademark), etc.

[0022] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." In other words, "A and / or B" means that it may be only A, only B, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" is also applied when three or more things are expressed connected by "and / or."

[0023] [First embodiment]

[0024] FIG. 1 shows an example of the configuration of a data processing system 10 according to the first embodiment.

[0025] 1, a 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.

[0026] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0028] The reception device 38 includes a touch panel 38A, a microphone 38B, and the like, and receives user input. The touch panel 38A detects contact with an indicator (for example, a pen or a finger) to receive user input by the touch of the indicator. The microphone 38B detects the user's voice to receive user input by voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and the 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.

[0029] 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 of expression that the user 20 can perceive (for example, audio and / or text). The display 40A displays visible information such as text and images in accordance with instructions from the processor 46. The speaker 40B outputs audio in accordance with instructions from the processor 46. The camera 42 is a compact digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0030] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54.

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

[0032] 2, in the data processing device 12, a specific process 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" according to the technology of the present 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 process 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.

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

[0034] In the smart device 14, the processor 46 performs the reception output process. The storage 50 stores a reception output program 60. The reception output program 60 is used in conjunction with the 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 process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

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

[0036] This invention is a system for automating the refactoring of outdated systems to ensure efficient and stable maintenance and operation. This system uses generated artificial intelligence to perform detailed analysis of program code and network configurations, and optimizes them in a cloud environment. It then updates the system based on the optimized structure, achieving stable operation.

[0037] Explanation of program processing

[0038] First, the user installs the plugin into the old system to be refactored, then the user specifies the root directory path of the system, which starts analyzing the system's code and network configuration.

[0039] The device initializes a class called SystemAnalyzer using the specified system path. This class analyzes the program code of the target system and extracts class diagrams and interface specifications. The analysis results are visualized to clarify the internal structure and dependencies.

[0040] Next, the device sends the analysis results to an AI service on the cloud. The cloud service endpoint uses a pre-configured URL (e.g., http: / / cloud.service.ai / refactor). The analysis results are sent to the cloud in JSON format, and the generated AI on the cloud uses this to generate an optimized code structure.

[0041] The cloud AI model on the server uses the latest technology and algorithms to generate an optimized structure based on the analysis results, which includes removing redundant code and designing new classes and interfaces, and then sends it back to the device.

[0042] The terminal that receives the optimized structure updates the system code based on it, replacing old classes and interfaces with new, optimized ones. It also provides the results of the program code analysis to the user as class diagrams and interface specifications, and receives feedback from the user.

[0043] After receiving user feedback, the terminal will further modify the optimized code as needed and complete final refactoring, which will make the system more stable and easier to maintain.

[0044] Through this process, the system addresses the problem of a shortage of IT personnel and enables efficient maintenance and operation of legacy systems. Specifically, it automates traditional manual refactoring work, improving system reliability and maintainability.

[0045] The processing flow will be explained below.

[0046] Step 1:

[0047] The user installs the plugin into the old system that is to be refactored.

[0048] Specific operation: The user downloads the plugin file from the official website or a designated repository, and then follows the installation instructions to install the plugin in the target system environment.

[0049] Step 2:

[0050] The user specifies the root directory path of the system to be refactored.

[0051] Specific action: The user edits the system configuration file or specifies the root directory path of the target system (e.g., / path / to / legacy / system) using a command line argument.

[0052] Step 3:

[0053] The device will initialize the SystemAnalyzer class using the specified system path.

[0054] Specific operation: The terminal creates an instance of the SystemAnalyzer class and sets the system path specified in the __init__() method, which determines the location of the system code to be analyzed.

[0055] Step 4:

[0056] The device uses the SystemAnalyzer class to analyze the system code.

[0057] Specific operation: The terminal calls the analyze_code() method of SystemAnalyzer, and internally uses the _parse_code() method to read the code file and extract class and interface information, resulting in the generated code structure.

[0058] Step 5:

[0059] The device sends the analysis results to an AI service on the cloud.

[0060] Specific operation: The device converts the analysis results into JSON format and sends them via a POST request to the pre-configured cloud AI service endpoint (e.g., http: / / cloud.service.ai / refactor).

[0061] Step 6:

[0062] The cloud AI service on the server performs refactoring based on the submitted code structure.

[0063] Specific operation: The server analyzes the received analysis results using its internal AI model and generates optimization suggestions, such as reviewing dependencies between classes and removing redundant code.

[0064] Step 7:

[0065] The server generates an optimized code structure and returns it to the terminal.

[0066] Specific operation: The server generates the optimized code structure in JSON format and returns it to the device through an HTTP response, allowing the device to receive the optimization information.

[0067] Step 8:

[0068] The terminal updates the system based on the optimized code structure.

[0069] Specific operation: The device automatically updates the system code based on the optimized structure received from the cloud AI service, specifically replacing outdated classes and interfaces with new, optimized ones.

[0070] Step 9:

[0071] The terminal notifies the user that the system update is complete.

[0072] Specific operation: Once the update is complete, the device will notify the user via the command line or log that "refactoring is complete."

[0073] Example 1

[0074] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0075] Refactoring of traditional systems is typically done manually, requiring a significant amount of time and effort. Furthermore, there is a high likelihood that problems will arise with the reliability and maintainability of the refactored code. This has led to a serious shortage of IT personnel. It is also difficult to visualize analysis results and appropriately incorporate user feedback.

[0076] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0077] In this invention, the server includes means for installing a plugin in the system to be refactored and specifying the system path, means for analyzing the program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the acquired optimized code structure, and means for providing the results to the user as a class diagram or interface specifications and receiving feedback from the user. This makes it possible to automate refactoring work and improve the reliability and maintainability of the system.

[0078] A "refactoring target" is an existing system that requires improvements to its software code or network configuration.

[0079] A "plug-in" is a software extension that is installed on a system to add specific functionality.

[0080] "System path" refers to a file path that indicates the root directory of the system being analyzed.

[0081] "Generated artificial intelligence" refers to the AI ​​model used to perform refactoring and optimization tasks.

[0082] "Program Code" means the collection of source code that constitutes a computer program.

[0083] "Network configuration" refers to the structure and configuration of how network devices and software within a system are interconnected.

[0084] "Analysis" is the process of examining program code and network configurations in detail to reveal their structure and dependencies.

[0085] The "cloud" refers to remote servers and data storage provided over the internet.

[0086] "Optimization" refers to the process of improving program code and network configuration in order to improve system performance and maintainability.

[0087] A "class diagram" is a diagram that visually represents the structure of classes and the relationships between them in object-oriented programming.

[0088] An "interface specification" is a document or diagram that details the communication methods and protocols between software components.

[0089] "Feedback" refers to comments and correction requests provided by users.

[0090] "System reliability" refers to the ability of a system to operate stably without failures or errors.

[0091] "Maintainability" refers to the ability of software or systems to be easily changed or updated.

[0092] The present invention is a system for automating the refactoring of old systems and for efficient and stable maintenance and operation. Specifically, the invention is implemented using the following hardware and software.

[0093] Hardware and Software

[0094] Plugins: Software extensions that are installed on the system being refactored.

[0095] SystemAnalyzer: A software class that analyzes program code and network configurations.

[0096] Cloud AI Service: Uses AI models running on the cloud. The endpoint URL is http: / / cloud.service.ai / refactor.

[0097] Data processing and calculation

[0098] First, the user installs a dedicated plugin into the system to be refactored. This plugin is a tool for analyzing the system's code and network configuration. Next, the user specifies the root directory path of the system to be analyzed. Based on this specification, analysis of the program code and network configuration begins.

[0099] The device initializes the SystemAnalyzer class using the specified system path. This class analyzes the code and extracts class diagrams and interface specifications. The analysis results are visualized to reveal internal structures and dependencies.

[0100] The analysis results are sent in JSON format to an AI service on the cloud. The data includes details of each class's functions, methods, fields, and so on. The cloud AI model on the server uses the latest technology and algorithms to generate an optimized code structure based on the received analysis results. This optimization includes the design of new classes and interfaces. The generated structure is then sent back to the device.

[0101] The terminal that receives the optimized structure updates the system code accordingly, replacing old classes and interfaces with new, optimized ones, and providing the analysis results to the user as class diagrams and interface specifications, and receiving user feedback.

[0102] Users can review the provided class diagrams and interface specifications and provide feedback, for example, making specific requests such as "I want X to be added as a method in this new class." Based on the user's feedback, the device will further optimize the code and complete the final refactoring.

[0103] Specific examples

[0104] A company has an inventory management system that was developed 20 years ago. This system is still in operation, but maintenance is becoming difficult due to the complexity of the code and the large number of dependencies. A user specifies the root directory path of this system, installs a plugin, and starts analysis.

[0105] Example prompt sentence:

[0106] Simply specify the root directory path of your old inventory management system to start the analysis, then send the analysis results to our cloud-based AI service to generate an optimized structure.

[0107] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0108] Step 1:

[0109] The user installs a plugin into the system to be refactored. The input is the user clicking the install button. The output is that the plugin installation is complete and the system is ready to analyze program code and network configuration. In this step, the required libraries and modules are added to the system as the plugin is installed.

[0110] Step 2:

[0111] The user specifies the root directory path of the system to be analyzed. The input is that the user enters the path information into an input field. The output is that the path information is correctly recognized and the basic data is set to proceed to the next analysis step. In this step, the user specifies the root path, for example, "C:\OldInventorySystem."

[0112] Step 3:

[0113] The device initializes the SystemAnalyzer class using the specified system path and analyzes the program code and network configuration. The input is the system path specified by the user in step 2. The output is the analysis results, in which class diagrams and interface specifications are extracted. In this step, as the analysis progresses, the inheritance relationships and dependencies of classes are made clear, and the results are visualized visually.

[0114] Step 4:

[0115] The device sends the analysis results to the AI ​​service on the cloud. The input is the analysis results in JSON format obtained in step 3. The output is the start of the optimization process in the cloud AI service. This step includes sending the data to a cloud endpoint (e.g., http: / / cloud.service.ai / refactor) according to a communication protocol.

[0116] Step 5:

[0117] The cloud AI model on the server generates an optimized code structure based on the received analysis results. The input is the analysis results sent in step 4. The output is the generation of an optimized code structure, which is sent back to the device. In this step, the AI ​​model uses the latest technologies and algorithms to remove redundant code and design new class interfaces.

[0118] Step 6:

[0119] The terminal updates the system code based on the optimized structure received from the cloud. The input is the optimized code structure returned in step 5. The output is the updated system code and visually visualized class diagrams and interface specifications. In this step, new classes and interfaces replace the old ones, and the analysis results are provided to the user.

[0120] Step 7:

[0121] The user checks the provided class diagram and interface specifications and sends feedback. The input is the analysis results and specification diagram provided in step 6. The output is specific suggestions and correction requests from the user. In this step, the user sends feedback to the terminal, such as "I would like X to be added as a method of this new class."

[0122] Step 8:

[0123] The terminal further modifies the optimized code based on user feedback and completes the final refactoring. The input is the feedback received from the user in step 7. The output is the final modified system code. In this step, the code is manually modified based on the feedback, and the system is fully updated.

[0124] (Application example 1)

[0125] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0126] Currently, industrial equipment control systems are used for long periods of time, resulting in outdated software and often difficult maintenance. This necessitates highly efficient and stable refactoring of these systems. However, manual refactoring is time-consuming and prone to errors. Furthermore, because proper refactoring requires specialized knowledge, there is a serious shortage of human resources. Further challenges arise when portable terminals are required for operation on-site, such as in factories.

[0127] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0128] In this invention, the server includes means for analyzing program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the acquired optimized code structure, and means for refactoring the control system for industrial equipment and operated by a portable terminal. This enables efficient refactoring of the control system for industrial equipment such as factory robots, and realizes automated maintenance and stable operation.

[0129] "Generated artificial intelligence" refers to a model trained using existing technology that has the ability to analyze and optimize program code and network configurations.

[0130] "Program code" is a set of instructions containing specified algorithms and structures that direct the operation of a computer system.

[0131] A "network configuration" is the layout and configuration of the physical and logical connections that computer systems use to communicate.

[0132] The "cloud" is a collection of resources, services, and data storage provided over the internet, and is a data center with the ability to store, process, and optimize analytical results.

[0133] "Code structure" is the design and organizational form of program code, showing the relationships between classes, methods, and interfaces.

[0134] "Industrial equipment" is a general term for machinery and equipment used in production and processing processes, including their control systems.

[0135] A "control system" is a combination of software and hardware used to monitor and direct the operation of industrial equipment and other devices.

[0136] "Refactoring" is the process of redesigning the internal structure of a current system without changing its external behavior, thereby improving its efficiency and maintainability.

[0137] "Portable terminal" means a device that can be carried around and used for operation and display of data. This includes tablets and smartphones.

[0138] A "class diagram" is a visual diagram used in object-oriented design that shows a system's classes and their relationships.

[0139] An "interface specification" is a document that defines the standard protocols and methods for different systems or components to communicate with each other.

[0140] "Feedback" refers to opinions and information provided by end users regarding their usage experience and areas for improvement, which are useful for optimizing the system.

[0141] This invention is a highly efficient and stable system for refactoring industrial equipment control systems. This system consists of the following major components: means for analyzing program code and network configurations using generated artificial intelligence, means for transmitting the analysis results to the cloud and obtaining an optimized code structure, means for automatically updating the program code based on the obtained optimized code structure, and means for being operated by a portable terminal.

[0142] Hardware and software used

[0143] Hardware:

[0144] Portable devices such as smartphones and tablets

[0145] Industrial equipment used in factories

[0146] software:

[0147] Refactoring System Plugin

[0148] Cloud AI Service (http: / / cloud.service.ai / refactor)

[0149] Class diagram and interface specification visualization tool

[0150] Program processing explanation

[0151] 1. The user installs the refactoring system plugin into the control system of the target industrial equipment.

[0152] 2. The user specifies the root directory path of the control system using the portable terminal.

[0153] 3. Based on the specified path, the terminal initializes the SystemAnalyzer class and analyzes the program code and network configuration. This analysis generates a class diagram and interface specifications.

[0154] 4. The device sends the analysis results in JSON format to the cloud-based AI service. The cloud AI model generates an optimized code structure based on the analysis results and sends it back to the device.

[0155] 5. The terminal receives the optimized code structure and automatically updates the control system program code accordingly. Engineers can review class diagrams and interface specifications on the portable terminal and provide feedback as needed.

[0156] 6. The terminal receives user feedback, further modifies the optimization code, and completes the final refactoring.

[0157] Specific examples

[0158] For example, an engineer visiting an industrial facility to maintain its control system can install a refactoring system plug-in on their smartphone. By specifying the root directory path of the control system, the program code and network configuration are automatically analyzed, and an AI model running on the cloud generates an optimized code structure. The engineer can then update the control system with the optimized code and provide feedback to stabilize the system's operation.

[0159] Example prompt sentence:

[0160] Analyze the control system code of an industrial device and generate an optimized structure based on the latest technology. Below is the analysis result of the system code class diagram and interface specification:

[0161] Class diagram: [insert class diagram here]

[0162] Interface Specification: [insert interface specification here]

[0163] Requirements: Optimize the operation of the system by designing new classes and interfaces and removing redundant code.

[0164] Through this process, the refactoring of industrial equipment control systems is automated, significantly improving maintenance and operational efficiency.

[0165] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0166] Step 1:

[0167] The user installs the refactoring system plugin into the control system of the target industrial equipment. The input is the hardware and software environment of the control system connected to the industrial equipment. This gives the terminal access to the control system.

[0168] Step 2:

[0169] The user specifies the root directory path of the control system using a portable terminal (smartphone or tablet). The input is the file path specified by the user. The terminal obtains the program code and network configuration of the control system based on the specified path.

[0170] Step 3:

[0171] The terminal initializes the SystemAnalyzer class and analyzes the acquired program code and network configuration. The input is the file in the specified root directory path and network configuration information. As a result of the analysis, a class diagram and interface specifications are generated. The output is the class diagram and interface specifications as the analysis results.

[0172] Step 4:

[0173] The device sends the analysis results in JSON format to the AI ​​service on the cloud. The input is the analysis results generated in the previous step. This data is sent to the cloud. The cloud AI model on the server receives it and generates an optimized code structure. The output is the optimized code structure.

[0174] Step 5:

[0175] The cloud AI model generates an optimized code structure and sends it back to the device. The input is the cloud's data calculation and optimization algorithm based on the analysis results. The output is JSON data containing the optimized code structure.

[0176] Step 6:

[0177] The terminal receives the optimized code structure and automatically updates the program code of the control system based on it. The input is the optimized code structure sent from the server. The terminal updates the program code of the control system and implements new classes and interfaces. The output is the updated program code of the control system.

[0178] Step 7:

[0179] The user checks the class diagram and interface specifications on a portable terminal and provides feedback as needed. The input is the class diagram and interface specifications based on the optimized and updated program code. The output is the feedback from the user.

[0180] Step 8:

[0181] The device receives user feedback and further refines the optimized code. The input is the user feedback information. If necessary, it again connects with the cloud AI service to optimize the code and complete the final refactoring. The output is the final optimized program code.

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

[0183] This invention relates to a system that uses generated artificial intelligence to analyze the program code and network configuration of old systems and automate refactoring. Furthermore, by combining it with an emotion engine that recognizes user emotions, feedback is effectively reflected and the system is optimized.

[0184] Explanation of program processing

[0185] First, the user installs the plugin into the old system to be refactored, then the user specifies the root directory path of the system, which then starts analyzing the system's code and network configuration.

[0186] The terminal initializes the SystemAnalyzer class using the specified system path. This is the process of analyzing the program code of the target system and extracting class diagrams and interface specifications. The analysis results are visualized to clarify the internal structure and dependencies.

[0187] Next, the device sends the analysis results to an AI service on the cloud. The cloud service endpoint uses a pre-configured URL (e.g., http: / / cloud.service.ai / refactor). The analysis results are sent to the cloud in JSON format, and the generated AI on the cloud uses this to generate an optimized code structure.

[0188] The cloud AI service on the server performs refactoring based on the submitted code structure. The server then analyzes the received analysis results using its internal AI model and generates optimization suggestions, such as reviewing dependencies between classes and removing redundant code.

[0189] The terminal that receives the optimized structure updates the system code based on it, replacing old classes and interfaces with new, optimized ones. It also provides the results of the program code analysis to the user as class diagrams and interface specifications, and receives feedback from the user.

[0190] Here, an emotion engine is incorporated into the user feedback. The device collects the user's emotion data via the emotion engine and sends it along with the feedback to a cloud service. The emotion data is used to gain a deeper understanding of the user's satisfaction and problems.

[0191] The server readjusts optimization suggestions based on the emotional data and further improves the code. For example, if a part of the code where the user is feeling stressed is identified, that part will be prioritized for optimization. In addition, for parts with a lot of positive emotional data, suggestions will be made to maintain that state.

[0192] Finally, the device updates the system based on the optimized code received from the cloud service and notifies the user, thereby achieving effective refactoring that takes user sentiment into account.

[0193] This system enables more appropriate and efficient system optimization by incorporating user emotional feedback into the automated refactoring process. Specifically, it identifies system improvements based on user emotional data and incorporates them into the system, thereby improving user satisfaction and system stability.

[0194] The processing flow will be explained below.

[0195] Step 1:

[0196] The user installs the plugin into the old system that is to be refactored.

[0197] How it works: Users download the plugin file from the official website or designated repository, install it in their system environment, and follow the installation instructions to install the plugin into their system with administrator privileges.

[0198] Step 2:

[0199] The user specifies the root directory path of the system to be refactored.

[0200] Specific operation: The user edits a configuration file or specifies the root directory path of the target system (e.g., / path / to / legacy / system) using a command line argument.

[0201] Step 3:

[0202] The device will initialize the SystemAnalyzer class using the specified system path.

[0203] Specific operation: The terminal creates an instance of the SystemAnalyzer class and sets the specified system path in the __init__() method, which determines the location of the system code to be analyzed.

[0204] Step 4:

[0205] The device uses the SystemAnalyzer class to analyze the system code.

[0206] Specific operation: The terminal calls the analyze_code() method of SystemAnalyzer, and internally uses the _parse_code() method to read the code file and extract class and interface information. The code structure is visually visualized as a class diagram and interface specification.

[0207] Step 5:

[0208] The device sends the analysis results to an AI service on the cloud.

[0209] Specific operation: The device converts the analysis results into JSON format and sends them to the cloud AI service endpoint (e.g., http: / / cloud.service.ai / refactor) via a POST request.

[0210] Step 6:

[0211] The cloud AI service on the server performs refactoring based on the submitted code structure.

[0212] Specific operation: The server analyzes the received analysis results using an AI model and generates optimization suggestions, such as reviewing dependencies between classes and removing redundant code.

[0213] Step 7:

[0214] The server generates an optimized code structure and returns it to the terminal.

[0215] Specific operation: The server generates the optimized code structure in JSON format and returns it to the device through an HTTP response, allowing the device to receive the optimization information.

[0216] Step 8:

[0217] The terminal updates the system based on the optimized code structure.

[0218] Specific operation: The device automatically updates the system code based on the optimized structure received from the cloud AI service, specifically replacing outdated classes and interfaces with new, optimized ones.

[0219] Step 9:

[0220] The terminal notifies the user that the system update is complete.

[0221] Specific operation: Once the update is complete, the device will notify the user via the command line or log that "refactoring is complete."

[0222] Step 10:

[0223] The device uses an emotion engine to collect user feedback.

[0224] Specific operation: The device collects emotional data such as facial expressions and voice from the user through the emotion engine, analyzes the data, identifies the user's emotional state (e.g., satisfaction, dissatisfaction, stress), and generates feedback based on that.

[0225] Step 11:

[0226] The device sends feedback along with emotional data to a cloud AI service.

[0227] Specific operation: The device converts the emotional data from the user into JSON format and sends it along with the analysis results to the cloud AI service endpoint via a POST request.

[0228] Step 12:

[0229] The server readjusts the optimization suggestions based on the emotional data.

[0230] Specific operation: The server analyzes the received emotional data and adjusts optimization suggestions based on the user's emotional state. For example, it prioritizes optimization of areas that cause stress, and makes suggestions to maintain the state of areas with a lot of positive emotional data.

[0231] Step 13:

[0232] The server sends the re-adjusted optimization proposal back to the device.

[0233] Specific operation: The server generates the retuned optimized structure in JSON format and returns it to the terminal via an HTTP response.

[0234] Step 14:

[0235] The device will update the system again and notify the user again.

[0236] Specific operation: The terminal updates the system code based on the re-adjusted optimization structure and finally notifies the user that "refactoring is complete."

[0237] Example 2

[0238] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0239] In the current system, refactoring old program code and network configurations requires a great deal of time and effort, and there is a significant lack of automation. Furthermore, there is no way to fully incorporate user feedback, which hinders efficient system improvements. Furthermore, there is no mechanism for utilizing user emotional data, making it difficult to improve satisfaction.

[0240] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0241] In this invention, the server includes means for analyzing program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the acquired optimized code structure, means for collecting feedback from users and analyzing their emotional data to adjust optimization proposals, and means for automatically updating the code again based on the optimization proposals generated by the cloud service. This enables automation and efficiency of refactoring work, and realizes advanced system optimization that takes user feedback and emotional data into consideration.

[0242] "Generated artificial intelligence" refers to machine learning models that are designed and trained to perform specific tasks.

[0243] "Program code" means a sequence of instructions for a computer to carry out.

[0244] A "network configuration" is the design and layout of how multiple computers or devices are connected to exchange information.

[0245] "Means for analysis" refers to means for identifying and understanding the internal structure and dependencies of program code and network configurations.

[0246] "Code structure to be optimized" refers to the design of program code that should be restructured for the purpose of improving performance and maintainability.

[0247] "Automatic update means" refers to a means by which a system or program automatically applies new code without human intervention.

[0248] "User feedback" refers to opinions and impressions provided by users of a system or service.

[0249] The "means for analyzing emotion data and adjusting optimization suggestions" refers to a means for changing the system's optimization suggestions based on the user's emotions.

[0250] "Cloud services" refer to computing resources and platforms provided over the Internet.

[0251] "Optimization proposals" are specific improvement measures to improve system performance and user experience.

[0252] This invention is a system that uses generated artificial intelligence to analyze the program code and network configuration of old systems and automate refactoring. Furthermore, by combining it with an emotion engine that recognizes user emotions, it effectively reflects feedback and optimizes the system.

[0253] The system uses the following hardware and software:

[0254] Hardware: Terminals, servers, cloud computing environments

[0255] Software: Plug-ins, emotion engines, code analysis software, cloud AI services

[0256] First, the user installs the plugin on the old system to be refactored. Next, the user specifies the root directory path of the system. For example, if the user specifies / path / to / old / system, this path will become the target of analysis. After this operation, the system's code and network configuration will be analyzed.

[0257] Specifically, the terminal initializes the SystemAnalyzer class using the specified system path. This class analyzes the program code of the target system and extracts class diagrams and interface specifications. The analysis results are visualized to clarify the internal structure and dependencies. The visualization results are provided, for example, as a web-based dashboard.

[0258] For example, run the analysis using the following prompt:

[0259] Prompt: "Please analyze the code and network structure of the system located at / path / to / old / system"

[0260] The device then sends the analysis results to an AI service on the cloud. The cloud service endpoint is pre-configured, for example, http: / / cloud.service.ai / refactor. The analysis results are sent to the cloud in text format rather than JSON format, and the AI ​​generated on the cloud uses this to generate an optimized code structure. During this process, AST (Abstract Syntax Tree) analysis is performed, and the internal structure and dependencies of the code are analyzed in detail.

[0261] For example, send the following prompt to the server:

[0262] Prompt: "Optimize the following code structure: Example class with method"

[0263] The cloud AI service on the server performs refactoring based on the received analysis results. Specifically, it reviews dependencies and removes redundant code. The generated optimization suggestions are returned to the device from the cloud AI service.

[0264] The terminal updates the system code based on the optimized code structure, replacing old classes and interfaces with new, optimized ones, and provides the results of the program code analysis to the user as class diagrams and interface specifications, and receives user feedback.

[0265] The device collects user emotional data via an emotion engine. For example, if a user finds a particular piece of code "difficult," that emotional data is collected as feedback and sent to a cloud service. This data is analyzed to identify user satisfaction and dissatisfaction.

[0266] The server then readjusts optimization suggestions based on the emotional data. For example, if it identifies areas where the user is feeling stressed, it generates suggestions to prioritize optimizing those areas of code. Additionally, if areas have a lot of positive emotional data, it makes suggestions to maintain that state.

[0267] Finally, the device updates the system based on the optimized code received from the cloud service and notifies the user. This process achieves effective refactoring that takes user sentiment into account.

[0268] As described above, the present invention realizes automation and efficiency of refactoring work, and further provides advanced system optimization that takes into account user feedback and emotional data.

[0269] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0270] Step 1:

[0271] The user installs a plugin into the old system to be refactored. Specifically, the user introduces a dedicated plugin into the system environment and verifies that it is initialized correctly. The input requires the installation directory of the old system and the plugin installation file, and the output is a state in which the plugin has started working correctly.

[0272] Step 2:

[0273] The user specifies the system root directory path, for example, / path / to / old / system using an interactive input window or command line. This path information is required as input, and this path is recorded as the target for analysis as output.

[0274] Step 3:

[0275] The device initializes the SystemAnalyzer class using the specified system path. This class has the ability to analyze program code and network configuration. Specific operations begin by reading the source code in the directory and then analyzing it to extract class diagrams and interface specifications. The source code in the specified path is required as input, and the resulting abstract syntax tree (AST) and dependency data are generated as output.

[0276] Step 4:

[0277] The device converts the analysis results into JSON format and sends them to the AI ​​service on the cloud. The destination is a pre-configured URL (e.g., http: / / cloud.service.ai / refactor). Specifically, the analysis results are serialized and sent to the cloud via an HTTP POST request. The input is the analysis results generated in the previous step, and the output is a successful submission status.

[0278] Step 5:

[0279] The cloud AI service on the server performs refactoring based on the received JSON data. It uses a generative AI model to restructure dependencies and perform optimizations such as removing redundant code. Specifically, the AI ​​analyzes the code and proposes improvements. The input to this process is JSON data, and the output is an optimized code structure.

[0280] Step 6:

[0281] The device receives the optimized code structure from the cloud AI service and updates the system code accordingly. Specifically, the old source code is replaced with the new, optimized code. The optimized code structure data is required as input, and the updated system code is obtained as output.

[0282] Step 7:

[0283] The terminal visualizes the analysis results of the program code and the optimized code as class diagrams and interface specifications and provides them to the user. Specifically, it uses a visualization tool to illustrate the class diagrams and interface specifications, which the user can view. The input is the analysis results and the optimized code, and the output is the visualized class diagrams and interface specifications.

[0284] Step 8:

[0285] The device uses an emotion engine to collect user feedback, such as capturing and analyzing user thoughts and emotions about a specific piece of code as text or voice. User feedback data is required as input, and emotion data is obtained as output.

[0286] Step 9:

[0287] The server readjusts the optimization suggestions based on the emotional data. Specifically, it prioritizes refactoring areas where users found it difficult and keeps areas that have received a lot of positive feedback. The input to this process is the emotional data, and the output is the readjusted optimization suggestions.

[0288] Step 10:

[0289] The device updates the system based on the optimized code received from the cloud service and notifies the user of the final result. Specifically, it applies the updated source code and reports the changes to the user. The input is the retuned optimized code, and the output is the updated system code and a notification message.

[0290] (Application example 2)

[0291] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0292] Robot systems in modern factories rely on complex program code and network configurations, but these systems become redundant over time and require optimization. Furthermore, traditional refactoring methods for periodic maintenance are performed manually, which is time-consuming, labor-intensive, and prone to errors. Furthermore, it is difficult to effectively incorporate operator feedback, making it difficult to improve usability and ensure system stability.

[0293] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[0294] In this invention, the server includes means for analyzing program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the optimized code structure, means for collecting feedback, and means for readjusting the optimization proposal based on the collected feedback and emotion data, thereby enabling effective refactoring of the factory robot system and continuous optimization that takes into account the emotions of the operators.

[0295] "Generated AI" refers to AI created using technologies such as machine learning and deep learning.

[0296] "Program code" refers to source code written to cause a computer to perform a specific operation.

[0297] A "network configuration" is a structure that shows the connections and arrangement of devices within a computer network.

[0298] "Optimized code structure" refers to the structure of program code that has been improved and optimized based on the analysis results.

[0299] A "feedback collection means" refers to a method or device for collecting information such as opinions, impressions, and feelings from users.

[0300] "Emotion data" refers to data that indicates the user's emotional state, including information that identifies, for example, joy, anger, sadness, etc.

[0301] "Optimization proposals" are proposals for improving program code and system configuration based on analysis results, feedback, and emotional data.

[0302] This invention describes an automated refactoring system applicable to factory robots. This system uses a generative AI model to analyze program code and network configurations and propose optimized code. Furthermore, it analyzes user sentiment data and reflects it in the optimization proposals, improving the system's efficiency and usability.

[0303] System Configuration

[0304] 1. Hardware:

[0305] Factory robot terminal: industrial computer

[0306] Server: A computer server on the cloud

[0307] Feedback collection devices: devices with emotion engines (e.g. emotion recognition cameras)

[0308] 2. Software:

[0309] emotion_engine library: A library for recognizing operator emotions

[0310] ai_refactor_service library: A library for working with cloud AI services

[0311] Analysis software: Software that analyzes program code and network configuration

[0312] Program processing explanation

[0313] The device first analyzes the program code and network configuration to be refactored. From this analysis, class diagrams and interface specifications are extracted and visualized. The analysis results are then sent to an AI service (ai_refactor_service library) on the cloud, which then generates optimization code suggestions.

[0314] The device that receives the optimization proposal automatically updates its program code based on the optimization code structure obtained from the cloud.

[0315] Furthermore, the terminal uses an emotion engine (emotion_engine library) to collect feedback and emotional data from the operator while working, allowing it to grasp the user's satisfaction and stress points in real time and send this information to a cloud AI service.

[0316] The server then adjusts the optimization suggestions based on the received feedback and emotional data. For example, it can prioritize optimizing code that causes stress to the user. The adjusted optimization code is then sent to the device, where it updates the system.

[0317] Specific examples

[0318] As a concrete example, consider a factory robot that manufactures certain automotive parts. During scheduled maintenance, the factory robot refactors the system. The analyzed program code and network configuration are sent to a cloud AI service, which generates optimization suggestions. The robot also collects operator sentiment data, which is used to further refine the optimization process.

[0319] Prompt Sentence Examples

[0320] "Submit the results of your code analysis. Generate optimization suggestions."

[0321] "This is operator sentiment data and feedback. Please use this to improve the code."

[0322] As described above, the system of the present invention not only automatically refactors the program code of factory robots, but also enables continuous optimization based on operator emotion data, thereby realizing efficient and user-friendly factory operations.

[0323] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0324] Step 1:

[0325] The device collects the program code and network configuration to be refactored. It takes the user-specified system path as input, reads the system's program code based on this path, and analyzes the network configuration. This code and network information are stored as internal data structures.

[0326] Step 2:

[0327] The terminal analyzes the collected program code and network configuration. The input for this analysis is the code and network information collected in step 1, and the output is analysis results such as class diagrams and interface specifications. The analysis results are then clearly visualized using the SystemAnalyzer class to reveal internal structures and dependencies.

[0328] Step 3:

[0329] The device sends the analysis results to an AI service on the cloud. Here, the analysis results are sent in JSON format to an endpoint (e.g., http: / / cloud.service.ai / refactor). The input is the analysis results obtained in step 2, and the cloud-based AI service generates optimization suggestions based on this. The optimized code structure is returned as the output.

[0330] Step 4:

[0331] The server performs refactoring based on the analysis results received from the cloud. It performs analysis using an internal AI model, for example, reviewing dependencies between classes and removing redundant code. The input is the analysis results sent in step 3, and the output is optimized program code.

[0332] Step 5:

[0333] The terminal automatically updates the program code based on the optimized code received from the server. This process involves replacing old classes and interfaces with new, optimized ones. The input is the optimized code received in step 4, and the output is the updated program code.

[0334] Step 6:

[0335] The terminal uses an emotion engine to collect operator feedback and emotion data. Emotional information is acquired in real time while the user is working and collected through a feedback device. The input is the emotion information sensed while the user is working, and the output is emotion data and feedback from the user.

[0336] Step 7:

[0337] The device sends the collected feedback and emotion data to the cloud AI service. Here, the emotion data and feedback obtained by the feedback device are sent in JSON format to an endpoint (e.g., http: / / cloud.service.ai / feedback). The input is the emotion data and feedback obtained in step 6, and the cloud-side AI service generates further optimization suggestions based on this.

[0338] Step 8:

[0339] The server readjusts the optimization proposal based on the received feedback and emotional data, performing operations such as prioritizing optimization of areas where the user felt stressed, and generates the final optimization proposal. The input is the feedback and emotional data sent in step 7, and the output is the readjusted optimization code.

[0340] Step 9:

[0341] The terminal receives the final optimization code and performs the final update of the program code based on it. This process involves the same operations as in step 5, and updates the system with the re-adjusted optimization code. The input is the optimization code received in step 8, and the output is the final updated program code.

[0342] 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 a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the 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.

[0343] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0344] In the above embodiment, an example in which the specific process is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific process may be performed by the smart device 14.

[0345] [Second embodiment]

[0346] FIG. 3 shows an example of the configuration of a data processing system 210 according to the second embodiment.

[0347] 3, the data processing system 210 includes the data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0348] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0350] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

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

[0352] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0353] Fig. 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Fig. 4, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0354] The specific processing program 56 is an example of a "program" according to the technology of the present 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.

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

[0356] In the smart glasses 214, the reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. 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 process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0357] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. 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."

[0358] This invention is a system for automating the refactoring of outdated systems to ensure efficient and stable maintenance and operation. This system uses generated artificial intelligence to perform detailed analysis of program code and network configurations, and optimizes them in a cloud environment. It then updates the system based on the optimized structure, achieving stable operation.

[0359] Explanation of program processing

[0360] First, the user installs the plugin into the old system to be refactored, then the user specifies the root directory path of the system, which starts analyzing the system's code and network configuration.

[0361] The device initializes a class called SystemAnalyzer using the specified system path. This class analyzes the program code of the target system and extracts class diagrams and interface specifications. The analysis results are visualized to clarify the internal structure and dependencies.

[0362] Next, the device sends the analysis results to an AI service on the cloud. The cloud service endpoint uses a pre-configured URL (e.g., http: / / cloud.service.ai / refactor). The analysis results are sent to the cloud in JSON format, and the generated AI on the cloud uses this to generate an optimized code structure.

[0363] The cloud AI model on the server uses the latest technology and algorithms to generate an optimized structure based on the analysis results, which includes removing redundant code and designing new classes and interfaces, and then sends it back to the device.

[0364] The terminal that receives the optimized structure updates the system code based on it, replacing old classes and interfaces with new, optimized ones. It also provides the results of the program code analysis to the user as class diagrams and interface specifications, and receives feedback from the user.

[0365] After receiving user feedback, the terminal will further modify the optimized code as needed and complete final refactoring, which will make the system more stable and easier to maintain.

[0366] Through this process, the system addresses the problem of a shortage of IT personnel and enables efficient maintenance and operation of legacy systems. Specifically, it automates traditional manual refactoring work, improving system reliability and maintainability.

[0367] The processing flow will be explained below.

[0368] Step 1:

[0369] The user installs the plugin into the old system that is to be refactored.

[0370] Specific operation: The user downloads the plugin file from the official website or a designated repository, and then follows the installation instructions to install the plugin in the target system environment.

[0371] Step 2:

[0372] The user specifies the root directory path of the system to be refactored.

[0373] Specific action: The user edits the system configuration file or specifies the root directory path of the target system (e.g., / path / to / legacy / system) using a command line argument.

[0374] Step 3:

[0375] The device will initialize the SystemAnalyzer class using the specified system path.

[0376] Specific operation: The terminal creates an instance of the SystemAnalyzer class and sets the system path specified in the __init__() method, which determines the location of the system code to be analyzed.

[0377] Step 4:

[0378] The device uses the SystemAnalyzer class to analyze the system code.

[0379] Specific operation: The terminal calls the analyze_code() method of SystemAnalyzer, and internally uses the _parse_code() method to read the code file and extract class and interface information, resulting in the generated code structure.

[0380] Step 5:

[0381] The device sends the analysis results to an AI service on the cloud.

[0382] Specific operation: The device converts the analysis results into JSON format and sends them via a POST request to the pre-configured cloud AI service endpoint (e.g., http: / / cloud.service.ai / refactor).

[0383] Step 6:

[0384] The cloud AI service on the server performs refactoring based on the submitted code structure.

[0385] Specific operation: The server analyzes the received analysis results using its internal AI model and generates optimization suggestions, such as reviewing dependencies between classes and removing redundant code.

[0386] Step 7:

[0387] The server generates an optimized code structure and returns it to the terminal.

[0388] Specific operation: The server generates the optimized code structure in JSON format and returns it to the device through an HTTP response, allowing the device to receive the optimization information.

[0389] Step 8:

[0390] The terminal updates the system based on the optimized code structure.

[0391] Specific operation: The device automatically updates the system code based on the optimized structure received from the cloud AI service, specifically replacing outdated classes and interfaces with new, optimized ones.

[0392] Step 9:

[0393] The terminal notifies the user that the system update is complete.

[0394] Specific operation: Once the update is complete, the device will notify the user via the command line or log that "refactoring is complete."

[0395] Example 1

[0396] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0397] Refactoring of traditional systems is typically done manually, requiring a significant amount of time and effort. Furthermore, there is a high likelihood that problems will arise with the reliability and maintainability of the refactored code. This has led to a serious shortage of IT personnel. It is also difficult to visualize analysis results and appropriately incorporate user feedback.

[0398] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0399] In this invention, the server includes means for installing a plugin in the system to be refactored and specifying the system path, means for analyzing the program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the acquired optimized code structure, and means for providing the results to the user as a class diagram or interface specifications and receiving feedback from the user. This makes it possible to automate refactoring work and improve the reliability and maintainability of the system.

[0400] A "refactoring target" is an existing system that requires improvements to its software code or network configuration.

[0401] A "plug-in" is a software extension that is installed on a system to add specific functionality.

[0402] "System path" refers to a file path that indicates the root directory of the system being analyzed.

[0403] "Generated artificial intelligence" refers to the AI ​​model used to perform refactoring and optimization tasks.

[0404] "Program Code" means the collection of source code that constitutes a computer program.

[0405] "Network configuration" refers to the structure and configuration of how network devices and software within a system are interconnected.

[0406] "Analysis" is the process of examining program code and network configurations in detail to reveal their structure and dependencies.

[0407] The "cloud" refers to remote servers and data storage provided over the internet.

[0408] "Optimization" refers to the process of improving program code and network configuration in order to improve system performance and maintainability.

[0409] A "class diagram" is a diagram that visually represents the structure of classes and the relationships between them in object-oriented programming.

[0410] An "interface specification" is a document or diagram that details the communication methods and protocols between software components.

[0411] "Feedback" refers to comments and correction requests provided by users.

[0412] "System reliability" refers to the ability of a system to operate stably without failures or errors.

[0413] "Maintainability" refers to the ability of software or systems to be easily changed or updated.

[0414] The present invention is a system for automating the refactoring of old systems and for efficient and stable maintenance and operation. Specifically, the invention is implemented using the following hardware and software.

[0415] Hardware and Software

[0416] Plugins: Software extensions that are installed on the system being refactored.

[0417] SystemAnalyzer: A software class that analyzes program code and network configurations.

[0418] Cloud AI Service: Uses AI models running on the cloud. The endpoint URL is http: / / cloud.service.ai / refactor.

[0419] Data processing and calculation

[0420] First, the user installs a dedicated plugin into the system to be refactored. This plugin is a tool for analyzing the system's code and network configuration. Next, the user specifies the root directory path of the system to be analyzed. Based on this specification, analysis of the program code and network configuration begins.

[0421] The device initializes the SystemAnalyzer class using the specified system path. This class analyzes the code and extracts class diagrams and interface specifications. The analysis results are visualized to reveal internal structures and dependencies.

[0422] The analysis results are sent in JSON format to an AI service on the cloud. The data includes details of each class's functions, methods, fields, and so on. The cloud AI model on the server uses the latest technology and algorithms to generate an optimized code structure based on the received analysis results. This optimization includes the design of new classes and interfaces. The generated structure is then sent back to the device.

[0423] The terminal that receives the optimized structure updates the system code accordingly, replacing old classes and interfaces with new, optimized ones, and providing the analysis results to the user as class diagrams and interface specifications, and receiving user feedback.

[0424] Users can review the provided class diagrams and interface specifications and provide feedback, for example, making specific requests such as "I want X to be added as a method in this new class." Based on the user's feedback, the device will further optimize the code and complete the final refactoring.

[0425] Specific examples

[0426] A company has an inventory management system that was developed 20 years ago. This system is still in operation, but maintenance is becoming difficult due to the complexity of the code and the large number of dependencies. A user specifies the root directory path of this system, installs a plugin, and starts analysis.

[0427] Example prompt sentence:

[0428] Simply specify the root directory path of your old inventory management system to start the analysis, then send the analysis results to our cloud-based AI service to generate an optimized structure.

[0429] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0430] Step 1:

[0431] The user installs a plugin into the system to be refactored. The input is the user clicking the install button. The output is that the plugin installation is complete and the system is ready to analyze program code and network configuration. In this step, the required libraries and modules are added to the system as the plugin is installed.

[0432] Step 2:

[0433] The user specifies the root directory path of the system to be analyzed. The input is that the user enters the path information into an input field. The output is that the path information is correctly recognized and the basic data is set to proceed to the next analysis step. In this step, the user specifies the root path, for example, "C:\OldInventorySystem."

[0434] Step 3:

[0435] The device initializes the SystemAnalyzer class using the specified system path and analyzes the program code and network configuration. The input is the system path specified by the user in step 2. The output is the analysis results, in which class diagrams and interface specifications are extracted. In this step, as the analysis progresses, the inheritance relationships and dependencies of classes are made clear, and the results are visualized visually.

[0436] Step 4:

[0437] The device sends the analysis results to the AI ​​service on the cloud. The input is the analysis results in JSON format obtained in step 3. The output is the start of the optimization process in the cloud AI service. This step includes sending the data to a cloud endpoint (e.g., http: / / cloud.service.ai / refactor) according to a communication protocol.

[0438] Step 5:

[0439] The cloud AI model on the server generates an optimized code structure based on the received analysis results. The input is the analysis results sent in step 4. The output is the generation of an optimized code structure, which is sent back to the device. In this step, the AI ​​model uses the latest technologies and algorithms to remove redundant code and design new class interfaces.

[0440] Step 6:

[0441] The terminal updates the system code based on the optimized structure received from the cloud. The input is the optimized code structure returned in step 5. The output is the updated system code and visually visualized class diagrams and interface specifications. In this step, new classes and interfaces replace the old ones, and the analysis results are provided to the user.

[0442] Step 7:

[0443] The user checks the provided class diagram and interface specifications and sends feedback. The input is the analysis results and specification diagram provided in step 6. The output is specific suggestions and correction requests from the user. In this step, the user sends feedback to the terminal, such as "I would like X to be added as a method of this new class."

[0444] Step 8:

[0445] The terminal further modifies the optimized code based on user feedback and completes the final refactoring. The input is the feedback received from the user in step 7. The output is the final modified system code. In this step, the code is manually modified based on the feedback, and the system is fully updated.

[0446] (Application example 1)

[0447] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0448] Currently, industrial equipment control systems are used for long periods of time, resulting in outdated software and often difficult maintenance. This necessitates highly efficient and stable refactoring of these systems. However, manual refactoring is time-consuming and prone to errors. Furthermore, because proper refactoring requires specialized knowledge, there is a serious shortage of human resources. Further challenges arise when portable terminals are required for operation on-site, such as in factories.

[0449] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0450] In this invention, the server includes means for analyzing program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the acquired optimized code structure, and means for refactoring the control system for industrial equipment and operated by a portable terminal. This enables efficient refactoring of the control system for industrial equipment such as factory robots, and realizes automated maintenance and stable operation.

[0451] "Generated artificial intelligence" refers to a model trained using existing technology that has the ability to analyze and optimize program code and network configurations.

[0452] "Program code" is a set of instructions containing specified algorithms and structures that direct the operation of a computer system.

[0453] A "network configuration" is the layout and configuration of the physical and logical connections that computer systems use to communicate.

[0454] The "cloud" is a collection of resources, services, and data storage provided over the internet, and is a data center with the ability to store, process, and optimize analytical results.

[0455] "Code structure" is the design and organizational form of program code, showing the relationships between classes, methods, and interfaces.

[0456] "Industrial equipment" is a general term for machinery and equipment used in production and processing processes, including their control systems.

[0457] A "control system" is a combination of software and hardware used to monitor and direct the operation of industrial equipment and other devices.

[0458] "Refactoring" is the process of redesigning the internal structure of a current system without changing its external behavior, thereby improving its efficiency and maintainability.

[0459] "Portable terminal" means a device that can be carried around and used for operation and display of data. This includes tablets and smartphones.

[0460] A "class diagram" is a visual diagram used in object-oriented design that shows a system's classes and their relationships.

[0461] An "interface specification" is a document that defines the standard protocols and methods for different systems or components to communicate with each other.

[0462] "Feedback" refers to opinions and information provided by end users regarding their usage experience and areas for improvement, which are useful for optimizing the system.

[0463] This invention is a highly efficient and stable system for refactoring industrial equipment control systems. This system consists of the following major components: means for analyzing program code and network configurations using generated artificial intelligence, means for transmitting the analysis results to the cloud and obtaining an optimized code structure, means for automatically updating the program code based on the obtained optimized code structure, and means for being operated by a portable terminal.

[0464] Hardware and software used

[0465] Hardware:

[0466] Portable devices such as smartphones and tablets

[0467] Industrial equipment used in factories

[0468] software:

[0469] Refactoring System Plugin

[0470] Cloud AI Service (http: / / cloud.service.ai / refactor)

[0471] Class diagram and interface specification visualization tool

[0472] Program processing explanation

[0473] 1. The user installs the refactoring system plugin into the control system of the target industrial equipment.

[0474] 2. The user specifies the root directory path of the control system using the portable terminal.

[0475] 3. Based on the specified path, the terminal initializes the SystemAnalyzer class and analyzes the program code and network configuration. This analysis generates a class diagram and interface specifications.

[0476] 4. The device sends the analysis results in JSON format to the cloud-based AI service. The cloud AI model generates an optimized code structure based on the analysis results and sends it back to the device.

[0477] 5. The terminal receives the optimized code structure and automatically updates the control system program code accordingly. Engineers can review class diagrams and interface specifications on the portable terminal and provide feedback as needed.

[0478] 6. The terminal receives user feedback, further modifies the optimization code, and completes the final refactoring.

[0479] Specific examples

[0480] For example, an engineer visiting an industrial facility to maintain its control system can install a refactoring system plug-in on their smartphone. By specifying the root directory path of the control system, the program code and network configuration are automatically analyzed, and an AI model running on the cloud generates an optimized code structure. The engineer can then update the control system with the optimized code and provide feedback to stabilize the system's operation.

[0481] Example prompt sentence:

[0482] Analyze the control system code of an industrial device and generate an optimized structure based on the latest technology. Below is the analysis result of the system code class diagram and interface specification:

[0483] Class diagram: [insert class diagram here]

[0484] Interface Specification: [insert interface specification here]

[0485] Requirements: Optimize the operation of the system by designing new classes and interfaces and removing redundant code.

[0486] Through this process, the refactoring of industrial equipment control systems is automated, significantly improving maintenance and operational efficiency.

[0487] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0488] Step 1:

[0489] The user installs the refactoring system plugin into the control system of the target industrial equipment. The input is the hardware and software environment of the control system connected to the industrial equipment. This gives the terminal access to the control system.

[0490] Step 2:

[0491] The user specifies the root directory path of the control system using a portable terminal (smartphone or tablet). The input is the file path specified by the user. The terminal obtains the program code and network configuration of the control system based on the specified path.

[0492] Step 3:

[0493] The terminal initializes the SystemAnalyzer class and analyzes the acquired program code and network configuration. The input is the file in the specified root directory path and network configuration information. As a result of the analysis, a class diagram and interface specifications are generated. The output is the class diagram and interface specifications as the analysis results.

[0494] Step 4:

[0495] The device sends the analysis results in JSON format to the AI ​​service on the cloud. The input is the analysis results generated in the previous step. This data is sent to the cloud. The cloud AI model on the server receives it and generates an optimized code structure. The output is the optimized code structure.

[0496] Step 5:

[0497] The cloud AI model generates an optimized code structure and sends it back to the device. The input is the cloud's data calculation and optimization algorithm based on the analysis results. The output is JSON data containing the optimized code structure.

[0498] Step 6:

[0499] The terminal receives the optimized code structure and automatically updates the program code of the control system based on it. The input is the optimized code structure sent from the server. The terminal updates the program code of the control system and implements new classes and interfaces. The output is the updated program code of the control system.

[0500] Step 7:

[0501] The user checks the class diagram and interface specifications on a portable terminal and provides feedback as needed. The input is the class diagram and interface specifications based on the optimized and updated program code. The output is the feedback from the user.

[0502] Step 8:

[0503] The device receives user feedback and further refines the optimized code. The input is the user feedback information. If necessary, it again connects with the cloud AI service to optimize the code and complete the final refactoring. The output is the final optimized program code.

[0504] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0505] This invention relates to a system that uses generated artificial intelligence to analyze the program code and network configuration of old systems and automate refactoring. Furthermore, by combining it with an emotion engine that recognizes user emotions, feedback is effectively reflected and the system is optimized.

[0506] Explanation of program processing

[0507] First, the user installs the plugin into the old system to be refactored, then the user specifies the root directory path of the system, which then starts analyzing the system's code and network configuration.

[0508] The terminal initializes the SystemAnalyzer class using the specified system path. This is the process of analyzing the program code of the target system and extracting class diagrams and interface specifications. The analysis results are visualized to clarify the internal structure and dependencies.

[0509] Next, the device sends the analysis results to an AI service on the cloud. The cloud service endpoint uses a pre-configured URL (e.g., http: / / cloud.service.ai / refactor). The analysis results are sent to the cloud in JSON format, and the generated AI on the cloud uses this to generate an optimized code structure.

[0510] The cloud AI service on the server performs refactoring based on the submitted code structure. The server then analyzes the received analysis results using its internal AI model and generates optimization suggestions, such as reviewing dependencies between classes and removing redundant code.

[0511] The terminal that receives the optimized structure updates the system code based on it, replacing old classes and interfaces with new, optimized ones. It also provides the results of the program code analysis to the user as class diagrams and interface specifications, and receives feedback from the user.

[0512] Here, an emotion engine is incorporated into the user feedback. The device collects the user's emotion data via the emotion engine and sends it along with the feedback to a cloud service. The emotion data is used to gain a deeper understanding of the user's satisfaction and problems.

[0513] The server readjusts optimization suggestions based on the emotional data and further improves the code. For example, if a part of the code where the user is feeling stressed is identified, that part will be prioritized for optimization. In addition, for parts with a lot of positive emotional data, suggestions will be made to maintain that state.

[0514] Finally, the device updates the system based on the optimized code received from the cloud service and notifies the user, thereby achieving effective refactoring that takes user sentiment into account.

[0515] This system enables more appropriate and efficient system optimization by incorporating user emotional feedback into the automated refactoring process. Specifically, it identifies system improvements based on user emotional data and incorporates them into the system, thereby improving user satisfaction and system stability.

[0516] The processing flow will be explained below.

[0517] Step 1:

[0518] The user installs the plugin into the old system that is to be refactored.

[0519] How it works: Users download the plugin file from the official website or designated repository, install it in their system environment, and follow the installation instructions to install the plugin into their system with administrator privileges.

[0520] Step 2:

[0521] The user specifies the root directory path of the system to be refactored.

[0522] Specific operation: The user edits a configuration file or specifies the root directory path of the target system (e.g., / path / to / legacy / system) using a command line argument.

[0523] Step 3:

[0524] The device will initialize the SystemAnalyzer class using the specified system path.

[0525] Specific operation: The terminal creates an instance of the SystemAnalyzer class and sets the specified system path in the __init__() method, which determines the location of the system code to be analyzed.

[0526] Step 4:

[0527] The device uses the SystemAnalyzer class to analyze the system code.

[0528] Specific operation: The terminal calls the analyze_code() method of SystemAnalyzer, and internally uses the _parse_code() method to read the code file and extract class and interface information. The code structure is visually visualized as a class diagram and interface specification.

[0529] Step 5:

[0530] The device sends the analysis results to an AI service on the cloud.

[0531] Specific operation: The device converts the analysis results into JSON format and sends them to the cloud AI service endpoint (e.g., http: / / cloud.service.ai / refactor) via a POST request.

[0532] Step 6:

[0533] The cloud AI service on the server performs refactoring based on the submitted code structure.

[0534] Specific operation: The server analyzes the received analysis results using an AI model and generates optimization suggestions, such as reviewing dependencies between classes and removing redundant code.

[0535] Step 7:

[0536] The server generates an optimized code structure and returns it to the terminal.

[0537] Specific operation: The server generates the optimized code structure in JSON format and returns it to the device through an HTTP response, allowing the device to receive the optimization information.

[0538] Step 8:

[0539] The terminal updates the system based on the optimized code structure.

[0540] Specific operation: The device automatically updates the system code based on the optimized structure received from the cloud AI service, specifically replacing outdated classes and interfaces with new, optimized ones.

[0541] Step 9:

[0542] The terminal notifies the user that the system update is complete.

[0543] Specific operation: Once the update is complete, the device will notify the user via the command line or log that "refactoring is complete."

[0544] Step 10:

[0545] The device uses an emotion engine to collect user feedback.

[0546] Specific operation: The device collects emotional data such as facial expressions and voice from the user through the emotion engine, analyzes the data, identifies the user's emotional state (e.g., satisfaction, dissatisfaction, stress), and generates feedback based on that.

[0547] Step 11:

[0548] The device sends feedback along with emotional data to a cloud AI service.

[0549] Specific operation: The device converts the emotional data from the user into JSON format and sends it along with the analysis results to the cloud AI service endpoint via a POST request.

[0550] Step 12:

[0551] The server readjusts the optimization suggestions based on the emotional data.

[0552] Specific operation: The server analyzes the received emotional data and adjusts optimization suggestions based on the user's emotional state. For example, it prioritizes optimization of areas that cause stress, and makes suggestions to maintain the state of areas with a lot of positive emotional data.

[0553] Step 13:

[0554] The server sends the re-adjusted optimization proposal back to the device.

[0555] Specific operation: The server generates the retuned optimized structure in JSON format and returns it to the terminal via an HTTP response.

[0556] Step 14:

[0557] The device will update the system again and notify the user again.

[0558] Specific operation: The terminal updates the system code based on the re-adjusted optimization structure and finally notifies the user that "refactoring is complete."

[0559] Example 2

[0560] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0561] In the current system, refactoring old program code and network configurations requires a great deal of time and effort, and there is a significant lack of automation. Furthermore, there is no way to fully incorporate user feedback, which hinders efficient system improvements. Furthermore, there is no mechanism for utilizing user emotional data, making it difficult to improve satisfaction.

[0562] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0563] In this invention, the server includes means for analyzing program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the acquired optimized code structure, means for collecting feedback from users and analyzing their emotional data to adjust optimization proposals, and means for automatically updating the code again based on the optimization proposals generated by the cloud service. This enables automation and efficiency of refactoring work, and realizes advanced system optimization that takes user feedback and emotional data into consideration.

[0564] "Generated artificial intelligence" refers to machine learning models that are designed and trained to perform specific tasks.

[0565] "Program code" means a sequence of instructions for a computer to carry out.

[0566] A "network configuration" is the design and layout of how multiple computers or devices are connected to exchange information.

[0567] "Means for analysis" refers to means for identifying and understanding the internal structure and dependencies of program code and network configurations.

[0568] "Code structure to be optimized" refers to the design of program code that should be restructured for the purpose of improving performance and maintainability.

[0569] "Automatic update means" refers to a means by which a system or program automatically applies new code without human intervention.

[0570] "User feedback" refers to opinions and impressions provided by users of a system or service.

[0571] The "means for analyzing emotion data and adjusting optimization suggestions" refers to a means for changing the system's optimization suggestions based on the user's emotions.

[0572] "Cloud services" refer to computing resources and platforms provided over the Internet.

[0573] "Optimization proposals" are specific improvement measures to improve system performance and user experience.

[0574] This invention is a system that uses generated artificial intelligence to analyze the program code and network configuration of old systems and automate refactoring. Furthermore, by combining it with an emotion engine that recognizes user emotions, it effectively reflects feedback and optimizes the system.

[0575] The system uses the following hardware and software:

[0576] Hardware: Terminals, servers, cloud computing environments

[0577] Software: Plug-ins, emotion engines, code analysis software, cloud AI services

[0578] First, the user installs the plugin on the old system to be refactored. Next, the user specifies the root directory path of the system. For example, if the user specifies / path / to / old / system, this path will become the target of analysis. After this operation, the system's code and network configuration will be analyzed.

[0579] Specifically, the terminal initializes the SystemAnalyzer class using the specified system path. This class analyzes the program code of the target system and extracts class diagrams and interface specifications. The analysis results are visualized to clarify the internal structure and dependencies. The visualization results are provided, for example, as a web-based dashboard.

[0580] For example, run the analysis using the following prompt:

[0581] Prompt: "Please analyze the code and network structure of the system located at / path / to / old / system"

[0582] The device then sends the analysis results to an AI service on the cloud. The cloud service endpoint is pre-configured, for example, http: / / cloud.service.ai / refactor. The analysis results are sent to the cloud in text format rather than JSON format, and the AI ​​generated on the cloud uses this to generate an optimized code structure. During this process, AST (Abstract Syntax Tree) analysis is performed, and the internal structure and dependencies of the code are analyzed in detail.

[0583] For example, send the following prompt to the server:

[0584] Prompt: "Optimize the following code structure: Example class with method"

[0585] The cloud AI service on the server performs refactoring based on the received analysis results. Specifically, it reviews dependencies and removes redundant code. The generated optimization suggestions are returned to the device from the cloud AI service.

[0586] The terminal updates the system code based on the optimized code structure, replacing old classes and interfaces with new, optimized ones, and provides the results of the program code analysis to the user as class diagrams and interface specifications, and receives user feedback.

[0587] The device collects user emotional data via an emotion engine. For example, if a user finds a particular piece of code "difficult," that emotional data is collected as feedback and sent to a cloud service. This data is analyzed to identify user satisfaction and dissatisfaction.

[0588] The server then readjusts optimization suggestions based on the emotional data. For example, if it identifies areas where the user is feeling stressed, it generates suggestions to prioritize optimizing those areas of code. Additionally, if areas have a lot of positive emotional data, it makes suggestions to maintain that state.

[0589] Finally, the device updates the system based on the optimized code received from the cloud service and notifies the user. This process achieves effective refactoring that takes user sentiment into account.

[0590] As described above, the present invention realizes automation and efficiency of refactoring work, and further provides advanced system optimization that takes into account user feedback and emotional data.

[0591] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0592] Step 1:

[0593] The user installs a plugin into the old system to be refactored. Specifically, the user introduces a dedicated plugin into the system environment and verifies that it is initialized correctly. The input requires the installation directory of the old system and the plugin installation file, and the output is a state in which the plugin has started working correctly.

[0594] Step 2:

[0595] The user specifies the system root directory path, for example, / path / to / old / system using an interactive input window or command line. This path information is required as input, and this path is recorded as the target for analysis as output.

[0596] Step 3:

[0597] The device initializes the SystemAnalyzer class using the specified system path. This class has the ability to analyze program code and network configuration. Specific operations begin by reading the source code in the directory and then analyzing it to extract class diagrams and interface specifications. The source code in the specified path is required as input, and the resulting abstract syntax tree (AST) and dependency data are generated as output.

[0598] Step 4:

[0599] The device converts the analysis results into JSON format and sends them to the AI ​​service on the cloud. The destination is a pre-configured URL (e.g., http: / / cloud.service.ai / refactor). Specifically, the analysis results are serialized and sent to the cloud via an HTTP POST request. The input is the analysis results generated in the previous step, and the output is a successful submission status.

[0600] Step 5:

[0601] The cloud AI service on the server performs refactoring based on the received JSON data. It uses a generative AI model to restructure dependencies and perform optimizations such as removing redundant code. Specifically, the AI ​​analyzes the code and proposes improvements. The input to this process is JSON data, and the output is an optimized code structure.

[0602] Step 6:

[0603] The device receives the optimized code structure from the cloud AI service and updates the system code accordingly. Specifically, the old source code is replaced with the new, optimized code. The optimized code structure data is required as input, and the updated system code is obtained as output.

[0604] Step 7:

[0605] The terminal visualizes the analysis results of the program code and the optimized code as class diagrams and interface specifications and provides them to the user. Specifically, it uses a visualization tool to illustrate the class diagrams and interface specifications, which the user can view. The input is the analysis results and the optimized code, and the output is the visualized class diagrams and interface specifications.

[0606] Step 8:

[0607] The device uses an emotion engine to collect user feedback, such as capturing and analyzing user thoughts and emotions about a specific piece of code as text or voice. User feedback data is required as input, and emotion data is obtained as output.

[0608] Step 9:

[0609] The server readjusts the optimization suggestions based on the emotional data. Specifically, it prioritizes refactoring areas where users found it difficult and keeps areas that have received a lot of positive feedback. The input to this process is the emotional data, and the output is the readjusted optimization suggestions.

[0610] Step 10:

[0611] The device updates the system based on the optimized code received from the cloud service and notifies the user of the final result. Specifically, it applies the updated source code and reports the changes to the user. The input is the retuned optimized code, and the output is the updated system code and a notification message.

[0612] (Application example 2)

[0613] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0614] Robot systems in modern factories rely on complex program code and network configurations, but these systems become redundant over time and require optimization. Furthermore, traditional refactoring methods for periodic maintenance are performed manually, which is time-consuming, labor-intensive, and prone to errors. Furthermore, it is difficult to effectively incorporate operator feedback, making it difficult to improve usability and ensure system stability.

[0615] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[0616] In this invention, the server includes means for analyzing program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the optimized code structure, means for collecting feedback, and means for readjusting the optimization proposal based on the collected feedback and emotion data, thereby enabling effective refactoring of the factory robot system and continuous optimization that takes into account the emotions of the operators.

[0617] "Generated AI" refers to AI created using technologies such as machine learning and deep learning.

[0618] "Program code" refers to source code written to cause a computer to perform a specific operation.

[0619] A "network configuration" is a structure that shows the connections and arrangement of devices within a computer network.

[0620] "Optimized code structure" refers to the structure of program code that has been improved and optimized based on the analysis results.

[0621] A "feedback collection means" refers to a method or device for collecting information such as opinions, impressions, and feelings from users.

[0622] "Emotion data" refers to data that indicates the user's emotional state, including information that identifies, for example, joy, anger, sadness, etc.

[0623] "Optimization proposals" are proposals for improving program code and system configuration based on analysis results, feedback, and emotional data.

[0624] This invention describes an automated refactoring system applicable to factory robots. This system uses a generative AI model to analyze program code and network configurations and propose optimized code. Furthermore, it analyzes user sentiment data and reflects it in the optimization proposals, improving the system's efficiency and usability.

[0625] System Configuration

[0626] 1. Hardware:

[0627] Factory robot terminal: industrial computer

[0628] Server: A computer server on the cloud

[0629] Feedback collection devices: devices with emotion engines (e.g. emotion recognition cameras)

[0630] 2. Software:

[0631] emotion_engine library: A library for recognizing operator emotions

[0632] ai_refactor_service library: A library for working with cloud AI services

[0633] Analysis software: Software that analyzes program code and network configuration

[0634] Program processing explanation

[0635] The device first analyzes the program code and network configuration to be refactored. From this analysis, class diagrams and interface specifications are extracted and visualized. The analysis results are then sent to an AI service (ai_refactor_service library) on the cloud, which then generates optimization code suggestions.

[0636] The device that receives the optimization proposal automatically updates its program code based on the optimization code structure obtained from the cloud.

[0637] Furthermore, the terminal uses an emotion engine (emotion_engine library) to collect feedback and emotional data from the operator while working, allowing it to grasp the user's satisfaction and stress points in real time and send this information to a cloud AI service.

[0638] The server then adjusts the optimization suggestions based on the received feedback and emotional data. For example, it can prioritize optimizing code that causes stress to the user. The adjusted optimization code is then sent to the device, where it updates the system.

[0639] Specific examples

[0640] As a concrete example, consider a factory robot that manufactures certain automotive parts. During scheduled maintenance, the factory robot refactors the system. The analyzed program code and network configuration are sent to a cloud AI service, which generates optimization suggestions. The robot also collects operator sentiment data, which is used to further refine the optimization process.

[0641] Prompt Sentence Examples

[0642] "Submit the results of your code analysis. Generate optimization suggestions."

[0643] "This is operator sentiment data and feedback. Please use this to improve the code."

[0644] As described above, the system of the present invention not only automatically refactors the program code of factory robots, but also enables continuous optimization based on operator emotion data, thereby realizing efficient and user-friendly factory operations.

[0645] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0646] Step 1:

[0647] The device collects the program code and network configuration to be refactored. It takes the user-specified system path as input, reads the system's program code based on this path, and analyzes the network configuration. This code and network information are stored as internal data structures.

[0648] Step 2:

[0649] The terminal analyzes the collected program code and network configuration. The input for this analysis is the code and network information collected in step 1, and the output is analysis results such as class diagrams and interface specifications. The analysis results are then clearly visualized using the SystemAnalyzer class to reveal internal structures and dependencies.

[0650] Step 3:

[0651] The device sends the analysis results to an AI service on the cloud. Here, the analysis results are sent in JSON format to an endpoint (e.g., http: / / cloud.service.ai / refactor). The input is the analysis results obtained in step 2, and the cloud-based AI service generates optimization suggestions based on this. The optimized code structure is returned as the output.

[0652] Step 4:

[0653] The server performs refactoring based on the analysis results received from the cloud. It performs analysis using an internal AI model, for example, reviewing dependencies between classes and removing redundant code. The input is the analysis results sent in step 3, and the output is optimized program code.

[0654] Step 5:

[0655] The terminal automatically updates the program code based on the optimized code received from the server. This process involves replacing old classes and interfaces with new, optimized ones. The input is the optimized code received in step 4, and the output is the updated program code.

[0656] Step 6:

[0657] The terminal uses an emotion engine to collect operator feedback and emotion data. Emotional information is acquired in real time while the user is working and collected through a feedback device. The input is the emotion information sensed while the user is working, and the output is emotion data and feedback from the user.

[0658] Step 7:

[0659] The device sends the collected feedback and emotion data to the cloud AI service. Here, the emotion data and feedback obtained by the feedback device are sent in JSON format to an endpoint (e.g., http: / / cloud.service.ai / feedback). The input is the emotion data and feedback obtained in step 6, and the cloud-side AI service generates further optimization suggestions based on this.

[0660] Step 8:

[0661] The server readjusts the optimization proposal based on the received feedback and emotional data, performing operations such as prioritizing optimization of areas where the user felt stressed, and generates the final optimization proposal. The input is the feedback and emotional data sent in step 7, and the output is the readjusted optimization code.

[0662] Step 9:

[0663] The terminal receives the final optimization code and performs the final update of the program code based on it. This process involves the same operations as in step 5, and updates the system with the re-adjusted optimization code. The input is the optimization code received in step 8, and the output is the final updated program code.

[0664] 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 a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0665] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0666] In the above embodiment, an example in which the specific processing is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the smart glasses 214.

[0667] [Third embodiment]

[0668] FIG. 5 shows an example of the configuration of a data processing system 310 according to the third embodiment.

[0669] 5, the data processing system 310 includes the data processing device 12 and a headset terminal 314. An example of the data processing device 12 is a server.

[0670] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0672] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

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

[0674] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0675] Fig. 6 shows an example of the main functions of the data processing device 12 and the headset type terminal 314. As shown in Fig. 6, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0676] The specific processing program 56 is an example of a "program" according to the technology of the present 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.

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

[0678] In the headset type terminal 314, a reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. 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 process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0679] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. 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."

[0680] This invention is a system for automating the refactoring of outdated systems to ensure efficient and stable maintenance and operation. This system uses generated artificial intelligence to perform detailed analysis of program code and network configurations, and optimizes them in a cloud environment. It then updates the system based on the optimized structure, achieving stable operation.

[0681] Explanation of program processing

[0682] First, the user installs the plugin into the old system to be refactored, then the user specifies the root directory path of the system, which starts analyzing the system's code and network configuration.

[0683] The device initializes a class called SystemAnalyzer using the specified system path. This class analyzes the program code of the target system and extracts class diagrams and interface specifications. The analysis results are visualized to clarify the internal structure and dependencies.

[0684] Next, the device sends the analysis results to an AI service on the cloud. The cloud service endpoint uses a pre-configured URL (e.g., http: / / cloud.service.ai / refactor). The analysis results are sent to the cloud in JSON format, and the generated AI on the cloud uses this to generate an optimized code structure.

[0685] The cloud AI model on the server uses the latest technology and algorithms to generate an optimized structure based on the analysis results, which includes removing redundant code and designing new classes and interfaces, and then sends it back to the device.

[0686] The terminal that receives the optimized structure updates the system code based on it, replacing old classes and interfaces with new, optimized ones. It also provides the results of the program code analysis to the user as class diagrams and interface specifications, and receives feedback from the user.

[0687] After receiving user feedback, the terminal will further modify the optimized code as needed and complete final refactoring, which will make the system more stable and easier to maintain.

[0688] Through this process, the system addresses the problem of a shortage of IT personnel and enables efficient maintenance and operation of legacy systems. Specifically, it automates traditional manual refactoring work, improving system reliability and maintainability.

[0689] The processing flow will be explained below.

[0690] Step 1:

[0691] The user installs the plugin into the old system that is to be refactored.

[0692] Specific operation: The user downloads the plugin file from the official website or a designated repository, and then follows the installation instructions to install the plugin in the target system environment.

[0693] Step 2:

[0694] The user specifies the root directory path of the system to be refactored.

[0695] Specific action: The user edits the system configuration file or specifies the root directory path of the target system (e.g., / path / to / legacy / system) using a command line argument.

[0696] Step 3:

[0697] The device will initialize the SystemAnalyzer class using the specified system path.

[0698] Specific operation: The terminal creates an instance of the SystemAnalyzer class and sets the system path specified in the __init__() method, which determines the location of the system code to be analyzed.

[0699] Step 4:

[0700] The device uses the SystemAnalyzer class to analyze the system code.

[0701] Specific operation: The terminal calls the analyze_code() method of SystemAnalyzer, and internally uses the _parse_code() method to read the code file and extract class and interface information, resulting in the generated code structure.

[0702] Step 5:

[0703] The device sends the analysis results to an AI service on the cloud.

[0704] Specific operation: The device converts the analysis results into JSON format and sends them via a POST request to the pre-configured cloud AI service endpoint (e.g., http: / / cloud.service.ai / refactor).

[0705] Step 6:

[0706] The cloud AI service on the server performs refactoring based on the submitted code structure.

[0707] Specific operation: The server analyzes the received analysis results using its internal AI model and generates optimization suggestions, such as reviewing dependencies between classes and removing redundant code.

[0708] Step 7:

[0709] The server generates an optimized code structure and returns it to the terminal.

[0710] Specific operation: The server generates the optimized code structure in JSON format and returns it to the device through an HTTP response, allowing the device to receive the optimization information.

[0711] Step 8:

[0712] The terminal updates the system based on the optimized code structure.

[0713] Specific operation: The device automatically updates the system code based on the optimized structure received from the cloud AI service, specifically replacing outdated classes and interfaces with new, optimized ones.

[0714] Step 9:

[0715] The terminal notifies the user that the system update is complete.

[0716] Specific operation: Once the update is complete, the device will notify the user via the command line or log that "refactoring is complete."

[0717] Example 1

[0718] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0719] Refactoring of traditional systems is typically done manually, requiring a significant amount of time and effort. Furthermore, there is a high likelihood that problems will arise with the reliability and maintainability of the refactored code. This has led to a serious shortage of IT personnel. It is also difficult to visualize analysis results and appropriately incorporate user feedback.

[0720] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0721] In this invention, the server includes means for installing a plugin in the system to be refactored and specifying the system path, means for analyzing the program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the acquired optimized code structure, and means for providing the results to the user as a class diagram or interface specifications and receiving feedback from the user. This makes it possible to automate refactoring work and improve the reliability and maintainability of the system.

[0722] A "refactoring target" is an existing system that requires improvements to its software code or network configuration.

[0723] A "plug-in" is a software extension that is installed on a system to add specific functionality.

[0724] "System path" refers to a file path that indicates the root directory of the system being analyzed.

[0725] "Generated artificial intelligence" refers to the AI ​​model used to perform refactoring and optimization tasks.

[0726] "Program Code" means the collection of source code that constitutes a computer program.

[0727] "Network configuration" refers to the structure and configuration of how network devices and software within a system are interconnected.

[0728] "Analysis" is the process of examining program code and network configurations in detail to reveal their structure and dependencies.

[0729] The "cloud" refers to remote servers and data storage provided over the internet.

[0730] "Optimization" refers to the process of improving program code and network configuration in order to improve system performance and maintainability.

[0731] A "class diagram" is a diagram that visually represents the structure of classes and the relationships between them in object-oriented programming.

[0732] An "interface specification" is a document or diagram that details the communication methods and protocols between software components.

[0733] "Feedback" refers to comments and correction requests provided by users.

[0734] "System reliability" refers to the ability of a system to operate stably without failures or errors.

[0735] "Maintainability" refers to the ability of software or systems to be easily changed or updated.

[0736] The present invention is a system for automating the refactoring of old systems and for efficient and stable maintenance and operation. Specifically, the invention is implemented using the following hardware and software.

[0737] Hardware and Software

[0738] Plugins: Software extensions that are installed on the system being refactored.

[0739] SystemAnalyzer: A software class that analyzes program code and network configurations.

[0740] Cloud AI Service: Uses AI models running on the cloud. The endpoint URL is http: / / cloud.service.ai / refactor.

[0741] Data processing and calculation

[0742] First, the user installs a dedicated plugin into the system to be refactored. This plugin is a tool for analyzing the system's code and network configuration. Next, the user specifies the root directory path of the system to be analyzed. Based on this specification, analysis of the program code and network configuration begins.

[0743] The device initializes the SystemAnalyzer class using the specified system path. This class analyzes the code and extracts class diagrams and interface specifications. The analysis results are visualized to reveal internal structures and dependencies.

[0744] The analysis results are sent in JSON format to an AI service on the cloud. The data includes details of each class's functions, methods, fields, and so on. The cloud AI model on the server uses the latest technology and algorithms to generate an optimized code structure based on the received analysis results. This optimization includes the design of new classes and interfaces. The generated structure is then sent back to the device.

[0745] The terminal that receives the optimized structure updates the system code accordingly, replacing old classes and interfaces with new, optimized ones, and providing the analysis results to the user as class diagrams and interface specifications, and receiving user feedback.

[0746] Users can review the provided class diagrams and interface specifications and provide feedback, for example, making specific requests such as "I want X to be added as a method in this new class." Based on the user's feedback, the device will further optimize the code and complete the final refactoring.

[0747] Specific examples

[0748] A company has an inventory management system that was developed 20 years ago. This system is still in operation, but maintenance is becoming difficult due to the complexity of the code and the large number of dependencies. A user specifies the root directory path of this system, installs a plugin, and starts analysis.

[0749] Example prompt sentence:

[0750] Simply specify the root directory path of your old inventory management system to start the analysis, then send the analysis results to our cloud-based AI service to generate an optimized structure.

[0751] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0752] Step 1:

[0753] The user installs a plugin into the system to be refactored. The input is the user clicking the install button. The output is that the plugin installation is complete and the system is ready to analyze program code and network configuration. In this step, the required libraries and modules are added to the system as the plugin is installed.

[0754] Step 2:

[0755] The user specifies the root directory path of the system to be analyzed. The input is that the user enters the path information into an input field. The output is that the path information is correctly recognized and the basic data is set to proceed to the next analysis step. In this step, the user specifies the root path, for example, "C:\OldInventorySystem."

[0756] Step 3:

[0757] The device initializes the SystemAnalyzer class using the specified system path and analyzes the program code and network configuration. The input is the system path specified by the user in step 2. The output is the analysis results, in which class diagrams and interface specifications are extracted. In this step, as the analysis progresses, the inheritance relationships and dependencies of classes are made clear, and the results are visualized visually.

[0758] Step 4:

[0759] The device sends the analysis results to the AI ​​service on the cloud. The input is the analysis results in JSON format obtained in step 3. The output is the start of the optimization process in the cloud AI service. This step includes sending the data to a cloud endpoint (e.g., http: / / cloud.service.ai / refactor) according to a communication protocol.

[0760] Step 5:

[0761] The cloud AI model on the server generates an optimized code structure based on the received analysis results. The input is the analysis results sent in step 4. The output is the generation of an optimized code structure, which is sent back to the device. In this step, the AI ​​model uses the latest technologies and algorithms to remove redundant code and design new class interfaces.

[0762] Step 6:

[0763] The terminal updates the system code based on the optimized structure received from the cloud. The input is the optimized code structure returned in step 5. The output is the updated system code and visually visualized class diagrams and interface specifications. In this step, new classes and interfaces replace the old ones, and the analysis results are provided to the user.

[0764] Step 7:

[0765] The user checks the provided class diagram and interface specifications and sends feedback. The input is the analysis results and specification diagram provided in step 6. The output is specific suggestions and correction requests from the user. In this step, the user sends feedback to the terminal, such as "I would like X to be added as a method of this new class."

[0766] Step 8:

[0767] The terminal further modifies the optimized code based on user feedback and completes the final refactoring. The input is the feedback received from the user in step 7. The output is the final modified system code. In this step, the code is manually modified based on the feedback, and the system is fully updated.

[0768] (Application example 1)

[0769] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0770] Currently, industrial equipment control systems are used for long periods of time, resulting in outdated software and often difficult maintenance. This necessitates highly efficient and stable refactoring of these systems. However, manual refactoring is time-consuming and prone to errors. Furthermore, because proper refactoring requires specialized knowledge, there is a serious shortage of human resources. Further challenges arise when portable terminals are required for operation on-site, such as in factories.

[0771] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0772] In this invention, the server includes means for analyzing program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the acquired optimized code structure, and means for refactoring the control system for industrial equipment and operated by a portable terminal. This enables efficient refactoring of the control system for industrial equipment such as factory robots, and realizes automated maintenance and stable operation.

[0773] "Generated artificial intelligence" refers to a model trained using existing technology that has the ability to analyze and optimize program code and network configurations.

[0774] "Program code" is a set of instructions containing specified algorithms and structures that direct the operation of a computer system.

[0775] A "network configuration" is the layout and configuration of the physical and logical connections that computer systems use to communicate.

[0776] The "cloud" is a collection of resources, services, and data storage provided over the internet, and is a data center with the ability to store, process, and optimize analytical results.

[0777] "Code structure" is the design and organizational form of program code, showing the relationships between classes, methods, and interfaces.

[0778] "Industrial equipment" is a general term for machinery and equipment used in production and processing processes, including their control systems.

[0779] A "control system" is a combination of software and hardware used to monitor and direct the operation of industrial equipment and other devices.

[0780] "Refactoring" is the process of redesigning the internal structure of a current system without changing its external behavior, thereby improving its efficiency and maintainability.

[0781] "Portable terminal" means a device that can be carried around and used for operation and display of data. This includes tablets and smartphones.

[0782] A "class diagram" is a visual diagram used in object-oriented design that shows a system's classes and their relationships.

[0783] An "interface specification" is a document that defines the standard protocols and methods for different systems or components to communicate with each other.

[0784] "Feedback" refers to opinions and information provided by end users regarding their usage experience and areas for improvement, which are useful for optimizing the system.

[0785] This invention is a highly efficient and stable system for refactoring industrial equipment control systems. This system consists of the following major components: means for analyzing program code and network configurations using generated artificial intelligence, means for transmitting the analysis results to the cloud and obtaining an optimized code structure, means for automatically updating the program code based on the obtained optimized code structure, and means for being operated by a portable terminal.

[0786] Hardware and software used

[0787] Hardware:

[0788] Portable devices such as smartphones and tablets

[0789] Industrial equipment used in factories

[0790] software:

[0791] Refactoring System Plugin

[0792] Cloud AI Service (http: / / cloud.service.ai / refactor)

[0793] Class diagram and interface specification visualization tool

[0794] Program processing explanation

[0795] 1. The user installs the refactoring system plugin into the control system of the target industrial equipment.

[0796] 2. The user specifies the root directory path of the control system using the portable terminal.

[0797] 3. Based on the specified path, the terminal initializes the SystemAnalyzer class and analyzes the program code and network configuration. This analysis generates a class diagram and interface specifications.

[0798] 4. The device sends the analysis results in JSON format to the cloud-based AI service. The cloud AI model generates an optimized code structure based on the analysis results and sends it back to the device.

[0799] 5. The terminal receives the optimized code structure and automatically updates the control system program code accordingly. Engineers can review class diagrams and interface specifications on the portable terminal and provide feedback as needed.

[0800] 6. The terminal receives user feedback, further modifies the optimization code, and completes the final refactoring.

[0801] Specific examples

[0802] For example, an engineer visiting an industrial facility to maintain its control system can install a refactoring system plug-in on their smartphone. By specifying the root directory path of the control system, the program code and network configuration are automatically analyzed, and an AI model running on the cloud generates an optimized code structure. The engineer can then update the control system with the optimized code and provide feedback to stabilize the system's operation.

[0803] Example prompt sentence:

[0804] Analyze the control system code of an industrial device and generate an optimized structure based on the latest technology. Below is the analysis result of the system code class diagram and interface specification:

[0805] Class diagram: [insert class diagram here]

[0806] Interface Specification: [insert interface specification here]

[0807] Requirements: Optimize the operation of the system by designing new classes and interfaces and removing redundant code.

[0808] Through this process, the refactoring of industrial equipment control systems is automated, significantly improving maintenance and operational efficiency.

[0809] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0810] Step 1:

[0811] The user installs the refactoring system plugin into the control system of the target industrial equipment. The input is the hardware and software environment of the control system connected to the industrial equipment. This gives the terminal access to the control system.

[0812] Step 2:

[0813] The user specifies the root directory path of the control system using a portable terminal (smartphone or tablet). The input is the file path specified by the user. The terminal obtains the program code and network configuration of the control system based on the specified path.

[0814] Step 3:

[0815] The terminal initializes the SystemAnalyzer class and analyzes the acquired program code and network configuration. The input is the file in the specified root directory path and network configuration information. As a result of the analysis, a class diagram and interface specifications are generated. The output is the class diagram and interface specifications as the analysis results.

[0816] Step 4:

[0817] The device sends the analysis results in JSON format to the AI ​​service on the cloud. The input is the analysis results generated in the previous step. This data is sent to the cloud. The cloud AI model on the server receives it and generates an optimized code structure. The output is the optimized code structure.

[0818] Step 5:

[0819] The cloud AI model generates an optimized code structure and sends it back to the device. The input is the cloud's data calculation and optimization algorithm based on the analysis results. The output is JSON data containing the optimized code structure.

[0820] Step 6:

[0821] The terminal receives the optimized code structure and automatically updates the program code of the control system based on it. The input is the optimized code structure sent from the server. The terminal updates the program code of the control system and implements new classes and interfaces. The output is the updated program code of the control system.

[0822] Step 7:

[0823] The user checks the class diagram and interface specifications on a portable terminal and provides feedback as needed. The input is the class diagram and interface specifications based on the optimized and updated program code. The output is the feedback from the user.

[0824] Step 8:

[0825] The device receives user feedback and further refines the optimized code. The input is the user feedback information. If necessary, it again connects with the cloud AI service to optimize the code and complete the final refactoring. The output is the final optimized program code.

[0826] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0827] This invention relates to a system that uses generated artificial intelligence to analyze the program code and network configuration of old systems and automate refactoring. Furthermore, by combining it with an emotion engine that recognizes user emotions, feedback is effectively reflected and the system is optimized.

[0828] Explanation of program processing

[0829] First, the user installs the plugin into the old system to be refactored, then the user specifies the root directory path of the system, which then starts analyzing the system's code and network configuration.

[0830] The terminal initializes the SystemAnalyzer class using the specified system path. This is the process of analyzing the program code of the target system and extracting class diagrams and interface specifications. The analysis results are visualized to clarify the internal structure and dependencies.

[0831] Next, the device sends the analysis results to an AI service on the cloud. The cloud service endpoint uses a pre-configured URL (e.g., http: / / cloud.service.ai / refactor). The analysis results are sent to the cloud in JSON format, and the generated AI on the cloud uses this to generate an optimized code structure.

[0832] The cloud AI service on the server performs refactoring based on the submitted code structure. The server then analyzes the received analysis results using its internal AI model and generates optimization suggestions, such as reviewing dependencies between classes and removing redundant code.

[0833] The terminal that receives the optimized structure updates the system code based on it, replacing old classes and interfaces with new, optimized ones. It also provides the results of the program code analysis to the user as class diagrams and interface specifications, and receives feedback from the user.

[0834] Here, an emotion engine is incorporated into the user feedback. The device collects the user's emotion data via the emotion engine and sends it along with the feedback to a cloud service. The emotion data is used to gain a deeper understanding of the user's satisfaction and problems.

[0835] The server readjusts optimization suggestions based on the emotional data and further improves the code. For example, if a part of the code where the user is feeling stressed is identified, that part will be prioritized for optimization. In addition, for parts with a lot of positive emotional data, suggestions will be made to maintain that state.

[0836] Finally, the device updates the system based on the optimized code received from the cloud service and notifies the user, thereby achieving effective refactoring that takes user sentiment into account.

[0837] This system enables more appropriate and efficient system optimization by incorporating user emotional feedback into the automated refactoring process. Specifically, it identifies system improvements based on user emotional data and incorporates them into the system, thereby improving user satisfaction and system stability.

[0838] The processing flow will be explained below.

[0839] Step 1:

[0840] The user installs the plugin into the old system that is to be refactored.

[0841] How it works: Users download the plugin file from the official website or designated repository, install it in their system environment, and follow the installation instructions to install the plugin into their system with administrator privileges.

[0842] Step 2:

[0843] The user specifies the root directory path of the system to be refactored.

[0844] Specific operation: The user edits a configuration file or specifies the root directory path of the target system (e.g., / path / to / legacy / system) using a command line argument.

[0845] Step 3:

[0846] The device will initialize the SystemAnalyzer class using the specified system path.

[0847] Specific operation: The terminal creates an instance of the SystemAnalyzer class and sets the specified system path in the __init__() method, which determines the location of the system code to be analyzed.

[0848] Step 4:

[0849] The device uses the SystemAnalyzer class to analyze the system code.

[0850] Specific operation: The terminal calls the analyze_code() method of SystemAnalyzer, and internally uses the _parse_code() method to read the code file and extract class and interface information. The code structure is visually visualized as a class diagram and interface specification.

[0851] Step 5:

[0852] The device sends the analysis results to an AI service on the cloud.

[0853] Specific operation: The device converts the analysis results into JSON format and sends them to the cloud AI service endpoint (e.g., http: / / cloud.service.ai / refactor) via a POST request.

[0854] Step 6:

[0855] The cloud AI service on the server performs refactoring based on the submitted code structure.

[0856] Specific operation: The server analyzes the received analysis results using an AI model and generates optimization suggestions, such as reviewing dependencies between classes and removing redundant code.

[0857] Step 7:

[0858] The server generates an optimized code structure and returns it to the terminal.

[0859] Specific operation: The server generates the optimized code structure in JSON format and returns it to the device through an HTTP response, allowing the device to receive the optimization information.

[0860] Step 8:

[0861] The terminal updates the system based on the optimized code structure.

[0862] Specific operation: The device automatically updates the system code based on the optimized structure received from the cloud AI service, specifically replacing outdated classes and interfaces with new, optimized ones.

[0863] Step 9:

[0864] The terminal notifies the user that the system update is complete.

[0865] Specific operation: Once the update is complete, the device will notify the user via the command line or log that "refactoring is complete."

[0866] Step 10:

[0867] The device uses an emotion engine to collect user feedback.

[0868] Specific operation: The device collects emotional data such as facial expressions and voice from the user through the emotion engine, analyzes the data, identifies the user's emotional state (e.g., satisfaction, dissatisfaction, stress), and generates feedback based on that.

[0869] Step 11:

[0870] The device sends feedback along with emotional data to a cloud AI service.

[0871] Specific operation: The device converts the emotional data from the user into JSON format and sends it along with the analysis results to the cloud AI service endpoint via a POST request.

[0872] Step 12:

[0873] The server readjusts the optimization suggestions based on the emotional data.

[0874] Specific operation: The server analyzes the received emotional data and adjusts optimization suggestions based on the user's emotional state. For example, it prioritizes optimization of areas that cause stress, and makes suggestions to maintain the state of areas with a lot of positive emotional data.

[0875] Step 13:

[0876] The server sends the re-adjusted optimization proposal back to the device.

[0877] Specific operation: The server generates the retuned optimized structure in JSON format and returns it to the terminal via an HTTP response.

[0878] Step 14:

[0879] The device will update the system again and notify the user again.

[0880] Specific operation: The terminal updates the system code based on the re-adjusted optimization structure and finally notifies the user that "refactoring is complete."

[0881] Example 2

[0882] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0883] In the current system, refactoring old program code and network configurations requires a great deal of time and effort, and there is a significant lack of automation. Furthermore, there is no way to fully incorporate user feedback, which hinders efficient system improvements. Furthermore, there is no mechanism for utilizing user emotional data, making it difficult to improve satisfaction.

[0884] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0885] In this invention, the server includes means for analyzing program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the acquired optimized code structure, means for collecting feedback from users and analyzing their emotional data to adjust optimization proposals, and means for automatically updating the code again based on the optimization proposals generated by the cloud service. This enables automation and efficiency of refactoring work, and realizes advanced system optimization that takes user feedback and emotional data into consideration.

[0886] "Generated artificial intelligence" refers to machine learning models that are designed and trained to perform specific tasks.

[0887] "Program code" means a sequence of instructions for a computer to carry out.

[0888] A "network configuration" is the design and layout of how multiple computers or devices are connected to exchange information.

[0889] "Means for analysis" refers to means for identifying and understanding the internal structure and dependencies of program code and network configurations.

[0890] "Code structure to be optimized" refers to the design of program code that should be restructured for the purpose of improving performance and maintainability.

[0891] "Automatic update means" refers to a means by which a system or program automatically applies new code without human intervention.

[0892] "User feedback" refers to opinions and impressions provided by users of a system or service.

[0893] The "means for analyzing emotion data and adjusting optimization suggestions" refers to a means for changing the system's optimization suggestions based on the user's emotions.

[0894] "Cloud services" refer to computing resources and platforms provided over the Internet.

[0895] "Optimization proposals" are specific improvement measures to improve system performance and user experience.

[0896] This invention is a system that uses generated artificial intelligence to analyze the program code and network configuration of old systems and automate refactoring. Furthermore, by combining it with an emotion engine that recognizes user emotions, it effectively reflects feedback and optimizes the system.

[0897] The system uses the following hardware and software:

[0898] Hardware: Terminals, servers, cloud computing environments

[0899] Software: Plug-ins, emotion engines, code analysis software, cloud AI services

[0900] First, the user installs the plugin on the old system to be refactored. Next, the user specifies the root directory path of the system. For example, if the user specifies / path / to / old / system, this path will become the target of analysis. After this operation, the system's code and network configuration will be analyzed.

[0901] Specifically, the terminal initializes the SystemAnalyzer class using the specified system path. This class analyzes the program code of the target system and extracts class diagrams and interface specifications. The analysis results are visualized to clarify the internal structure and dependencies. The visualization results are provided, for example, as a web-based dashboard.

[0902] For example, run the analysis using the following prompt:

[0903] Prompt: "Please analyze the code and network structure of the system located at / path / to / old / system"

[0904] The device then sends the analysis results to an AI service on the cloud. The cloud service endpoint is pre-configured, for example, http: / / cloud.service.ai / refactor. The analysis results are sent to the cloud in text format rather than JSON format, and the AI ​​generated on the cloud uses this to generate an optimized code structure. During this process, AST (Abstract Syntax Tree) analysis is performed, and the internal structure and dependencies of the code are analyzed in detail.

[0905] For example, send the following prompt to the server:

[0906] Prompt: "Optimize the following code structure: Example class with method"

[0907] The cloud AI service on the server performs refactoring based on the received analysis results. Specifically, it reviews dependencies and removes redundant code. The generated optimization suggestions are returned to the device from the cloud AI service.

[0908] The terminal updates the system code based on the optimized code structure, replacing old classes and interfaces with new, optimized ones, and provides the results of the program code analysis to the user as class diagrams and interface specifications, and receives user feedback.

[0909] The device collects user emotional data via an emotion engine. For example, if a user finds a particular piece of code "difficult," that emotional data is collected as feedback and sent to a cloud service. This data is analyzed to identify user satisfaction and dissatisfaction.

[0910] The server then readjusts optimization suggestions based on the emotional data. For example, if it identifies areas where the user is feeling stressed, it generates suggestions to prioritize optimizing those areas of code. Additionally, if areas have a lot of positive emotional data, it makes suggestions to maintain that state.

[0911] Finally, the device updates the system based on the optimized code received from the cloud service and notifies the user. This process achieves effective refactoring that takes user sentiment into account.

[0912] As described above, the present invention realizes automation and efficiency of refactoring work, and further provides advanced system optimization that takes into account user feedback and emotional data.

[0913] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0914] Step 1:

[0915] The user installs a plugin into the old system to be refactored. Specifically, the user introduces a dedicated plugin into the system environment and verifies that it is initialized correctly. The input requires the installation directory of the old system and the plugin installation file, and the output is a state in which the plugin has started working correctly.

[0916] Step 2:

[0917] The user specifies the system root directory path, for example, / path / to / old / system using an interactive input window or command line. This path information is required as input, and this path is recorded as the target for analysis as output.

[0918] Step 3:

[0919] The device initializes the SystemAnalyzer class using the specified system path. This class has the ability to analyze program code and network configuration. Specific operations begin by reading the source code in the directory and then analyzing it to extract class diagrams and interface specifications. The source code in the specified path is required as input, and the resulting abstract syntax tree (AST) and dependency data are generated as output.

[0920] Step 4:

[0921] The device converts the analysis results into JSON format and sends them to the AI ​​service on the cloud. The destination is a pre-configured URL (e.g., http: / / cloud.service.ai / refactor). Specifically, the analysis results are serialized and sent to the cloud via an HTTP POST request. The input is the analysis results generated in the previous step, and the output is a successful submission status.

[0922] Step 5:

[0923] The cloud AI service on the server performs refactoring based on the received JSON data. It uses a generative AI model to restructure dependencies and perform optimizations such as removing redundant code. Specifically, the AI ​​analyzes the code and proposes improvements. The input to this process is JSON data, and the output is an optimized code structure.

[0924] Step 6:

[0925] The device receives the optimized code structure from the cloud AI service and updates the system code accordingly. Specifically, the old source code is replaced with the new, optimized code. The optimized code structure data is required as input, and the updated system code is obtained as output.

[0926] Step 7:

[0927] The terminal visualizes the analysis results of the program code and the optimized code as class diagrams and interface specifications and provides them to the user. Specifically, it uses a visualization tool to illustrate the class diagrams and interface specifications, which the user can view. The input is the analysis results and the optimized code, and the output is the visualized class diagrams and interface specifications.

[0928] Step 8:

[0929] The device uses an emotion engine to collect user feedback, such as capturing and analyzing user thoughts and emotions about a specific piece of code as text or voice. User feedback data is required as input, and emotion data is obtained as output.

[0930] Step 9:

[0931] The server readjusts the optimization suggestions based on the emotional data. Specifically, it prioritizes refactoring areas where users found it difficult and keeps areas that have received a lot of positive feedback. The input to this process is the emotional data, and the output is the readjusted optimization suggestions.

[0932] Step 10:

[0933] The device updates the system based on the optimized code received from the cloud service and notifies the user of the final result. Specifically, it applies the updated source code and reports the changes to the user. The input is the retuned optimized code, and the output is the updated system code and a notification message.

[0934] (Application example 2)

[0935] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0936] Robot systems in modern factories rely on complex program code and network configurations, but these systems become redundant over time and require optimization. Furthermore, traditional refactoring methods for periodic maintenance are performed manually, which is time-consuming, labor-intensive, and prone to errors. Furthermore, it is difficult to effectively incorporate operator feedback, making it difficult to improve usability and ensure system stability.

[0937] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[0938] In this invention, the server includes means for analyzing program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the optimized code structure, means for collecting feedback, and means for readjusting the optimization proposal based on the collected feedback and emotion data, thereby enabling effective refactoring of the factory robot system and continuous optimization that takes into account the emotions of the operators.

[0939] "Generated AI" refers to AI created using technologies such as machine learning and deep learning.

[0940] "Program code" refers to source code written to cause a computer to perform a specific operation.

[0941] A "network configuration" is a structure that shows the connections and arrangement of devices within a computer network.

[0942] "Optimized code structure" refers to the structure of program code that has been improved and optimized based on the analysis results.

[0943] A "feedback collection means" refers to a method or device for collecting information such as opinions, impressions, and feelings from users.

[0944] "Emotion data" refers to data that indicates the user's emotional state, including information that identifies, for example, joy, anger, sadness, etc.

[0945] "Optimization proposals" are proposals for improving program code and system configuration based on analysis results, feedback, and emotional data.

[0946] This invention describes an automated refactoring system applicable to factory robots. This system uses a generative AI model to analyze program code and network configurations and propose optimized code. Furthermore, it analyzes user sentiment data and reflects it in the optimization proposals, improving the system's efficiency and usability.

[0947] System Configuration

[0948] 1. Hardware:

[0949] Factory robot terminal: industrial computer

[0950] Server: A computer server on the cloud

[0951] Feedback collection devices: devices with emotion engines (e.g. emotion recognition cameras)

[0952] 2. Software:

[0953] emotion_engine library: A library for recognizing operator emotions

[0954] ai_refactor_service library: A library for working with cloud AI services

[0955] Analysis software: Software that analyzes program code and network configuration

[0956] Program processing explanation

[0957] The device first analyzes the program code and network configuration to be refactored. From this analysis, class diagrams and interface specifications are extracted and visualized. The analysis results are then sent to an AI service (ai_refactor_service library) on the cloud, which then generates optimization code suggestions.

[0958] The device that receives the optimization proposal automatically updates its program code based on the optimization code structure obtained from the cloud.

[0959] Furthermore, the terminal uses an emotion engine (emotion_engine library) to collect feedback and emotional data from the operator while working, allowing it to grasp the user's satisfaction and stress points in real time and send this information to a cloud AI service.

[0960] The server then adjusts the optimization suggestions based on the received feedback and emotional data. For example, it can prioritize optimizing code that causes stress to the user. The adjusted optimization code is then sent to the device, where it updates the system.

[0961] Specific examples

[0962] As a concrete example, consider a factory robot that manufactures certain automotive parts. During scheduled maintenance, the factory robot refactors the system. The analyzed program code and network configuration are sent to a cloud AI service, which generates optimization suggestions. The robot also collects operator sentiment data, which is used to further refine the optimization process.

[0963] Prompt Sentence Examples

[0964] "Submit the results of your code analysis. Generate optimization suggestions."

[0965] "This is operator sentiment data and feedback. Please use this to improve the code."

[0966] As described above, the system of the present invention not only automatically refactors the program code of factory robots, but also enables continuous optimization based on operator emotion data, thereby realizing efficient and user-friendly factory operations.

[0967] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0968] Step 1:

[0969] The device collects the program code and network configuration to be refactored. It takes the user-specified system path as input, reads the system's program code based on this path, and analyzes the network configuration. This code and network information are stored as internal data structures.

[0970] Step 2:

[0971] The terminal analyzes the collected program code and network configuration. The input for this analysis is the code and network information collected in step 1, and the output is analysis results such as class diagrams and interface specifications. The analysis results are then clearly visualized using the SystemAnalyzer class to reveal internal structures and dependencies.

[0972] Step 3:

[0973] The device sends the analysis results to an AI service on the cloud. Here, the analysis results are sent in JSON format to an endpoint (e.g., http: / / cloud.service.ai / refactor). The input is the analysis results obtained in step 2, and the cloud-based AI service generates optimization suggestions based on this. The optimized code structure is returned as the output.

[0974] Step 4:

[0975] The server performs refactoring based on the analysis results received from the cloud. It performs analysis using an internal AI model, for example, reviewing dependencies between classes and removing redundant code. The input is the analysis results sent in step 3, and the output is optimized program code.

[0976] Step 5:

[0977] The terminal automatically updates the program code based on the optimized code received from the server. This process involves replacing old classes and interfaces with new, optimized ones. The input is the optimized code received in step 4, and the output is the updated program code.

[0978] Step 6:

[0979] The terminal uses an emotion engine to collect operator feedback and emotion data. Emotional information is acquired in real time while the user is working and collected through a feedback device. The input is the emotion information sensed while the user is working, and the output is emotion data and feedback from the user.

[0980] Step 7:

[0981] The device sends the collected feedback and emotion data to the cloud AI service. Here, the emotion data and feedback obtained by the feedback device are sent in JSON format to an endpoint (e.g., http: / / cloud.service.ai / feedback). The input is the emotion data and feedback obtained in step 6, and the cloud-side AI service generates further optimization suggestions based on this.

[0982] Step 8:

[0983] The server readjusts the optimization proposal based on the received feedback and emotional data, performing operations such as prioritizing optimization of areas where the user felt stressed, and generates the final optimization proposal. The input is the feedback and emotional data sent in step 7, and the output is the readjusted optimization code.

[0984] Step 9:

[0985] The terminal receives the final optimization code and performs the final update of the program code based on it. This process involves the same operations as in step 5, and updates the system with the re-adjusted optimization code. The input is the optimization code received in step 8, and the output is the final updated program code.

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

[0987] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0988] 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 the present disclosure is not limited to this, and the specific processing may be performed by the headset type terminal 314.

[0989] [Fourth embodiment]

[0990] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

[0991] 7, a 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.

[0992] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0993] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a control target 443. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

[0994] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

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

[0996] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0997] The control object 443 includes a display device, LEDs in the eyes, and motors for driving 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 emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

[0998] Fig. 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Fig. 8, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0999] The specific processing program 56 is an example of a "program" according to the technology of the present 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.

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

[1001] In the robot 414, the processor 46 performs the reception output process. A reception output program 60 is stored in the storage 50. 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 process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

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

[1003] This invention is a system for automating the refactoring of outdated systems to ensure efficient and stable maintenance and operation. This system uses generated artificial intelligence to perform detailed analysis of program code and network configurations, and optimizes them in a cloud environment. It then updates the system based on the optimized structure, achieving stable operation.

[1004] Explanation of program processing

[1005] First, the user installs the plugin into the old system to be refactored, then the user specifies the root directory path of the system, which starts analyzing the system's code and network configuration.

[1006] The device initializes a class called SystemAnalyzer using the specified system path. This class analyzes the program code of the target system and extracts class diagrams and interface specifications. The analysis results are visualized to clarify the internal structure and dependencies.

[1007] Next, the device sends the analysis results to an AI service on the cloud. The cloud service endpoint uses a pre-configured URL (e.g., http: / / cloud.service.ai / refactor). The analysis results are sent to the cloud in JSON format, and the generated AI on the cloud uses this to generate an optimized code structure.

[1008] The cloud AI model on the server uses the latest technology and algorithms to generate an optimized structure based on the analysis results, which includes removing redundant code and designing new classes and interfaces, and then sends it back to the device.

[1009] The terminal that receives the optimized structure updates the system code based on it, replacing old classes and interfaces with new, optimized ones. It also provides the results of the program code analysis to the user as class diagrams and interface specifications, and receives feedback from the user.

[1010] After receiving user feedback, the terminal will further modify the optimized code as needed and complete final refactoring, which will make the system more stable and easier to maintain.

[1011] Through this process, the system addresses the problem of a shortage of IT personnel and enables efficient maintenance and operation of legacy systems. Specifically, it automates traditional manual refactoring work, improving system reliability and maintainability.

[1012] The processing flow will be explained below.

[1013] Step 1:

[1014] The user installs the plugin into the old system that is to be refactored.

[1015] Specific operation: The user downloads the plugin file from the official website or a designated repository, and then follows the installation instructions to install the plugin in the target system environment.

[1016] Step 2:

[1017] The user specifies the root directory path of the system to be refactored.

[1018] Specific action: The user edits the system configuration file or specifies the root directory path of the target system (e.g., / path / to / legacy / system) using a command line argument.

[1019] Step 3:

[1020] The device will initialize the SystemAnalyzer class using the specified system path.

[1021] Specific operation: The terminal creates an instance of the SystemAnalyzer class and sets the system path specified in the __init__() method, which determines the location of the system code to be analyzed.

[1022] Step 4:

[1023] The device uses the SystemAnalyzer class to analyze the system code.

[1024] Specific operation: The terminal calls the analyze_code() method of SystemAnalyzer, and internally uses the _parse_code() method to read the code file and extract class and interface information, resulting in the generated code structure.

[1025] Step 5:

[1026] The device sends the analysis results to an AI service on the cloud.

[1027] Specific operation: The device converts the analysis results into JSON format and sends them via a POST request to the pre-configured cloud AI service endpoint (e.g., http: / / cloud.service.ai / refactor).

[1028] Step 6:

[1029] The cloud AI service on the server performs refactoring based on the submitted code structure.

[1030] Specific operation: The server analyzes the received analysis results using its internal AI model and generates optimization suggestions, such as reviewing dependencies between classes and removing redundant code.

[1031] Step 7:

[1032] The server generates an optimized code structure and returns it to the terminal.

[1033] Specific operation: The server generates the optimized code structure in JSON format and returns it to the device through an HTTP response, allowing the device to receive the optimization information.

[1034] Step 8:

[1035] The terminal updates the system based on the optimized code structure.

[1036] Specific operation: The device automatically updates the system code based on the optimized structure received from the cloud AI service, specifically replacing outdated classes and interfaces with new, optimized ones.

[1037] Step 9:

[1038] The terminal notifies the user that the system update is complete.

[1039] Specific operation: Once the update is complete, the device will notify the user via the command line or log that "refactoring is complete."

[1040] Example 1

[1041] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1042] Refactoring of traditional systems is typically done manually, requiring a significant amount of time and effort. Furthermore, there is a high likelihood that problems will arise with the reliability and maintainability of the refactored code. This has led to a serious shortage of IT personnel. It is also difficult to visualize analysis results and appropriately incorporate user feedback.

[1043] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[1044] In this invention, the server includes means for installing a plugin in the system to be refactored and specifying the system path, means for analyzing the program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the acquired optimized code structure, and means for providing the results to the user as a class diagram or interface specifications and receiving feedback from the user. This makes it possible to automate refactoring work and improve the reliability and maintainability of the system.

[1045] A "refactoring target" is an existing system that requires improvements to its software code or network configuration.

[1046] A "plug-in" is a software extension that is installed on a system to add specific functionality.

[1047] "System path" refers to a file path that indicates the root directory of the system being analyzed.

[1048] "Generated artificial intelligence" refers to the AI ​​model used to perform refactoring and optimization tasks.

[1049] "Program Code" means the collection of source code that constitutes a computer program.

[1050] "Network configuration" refers to the structure and configuration of how network devices and software within a system are interconnected.

[1051] "Analysis" is the process of examining program code and network configurations in detail to reveal their structure and dependencies.

[1052] The "cloud" refers to remote servers and data storage provided over the internet.

[1053] "Optimization" refers to the process of improving program code and network configuration in order to improve system performance and maintainability.

[1054] A "class diagram" is a diagram that visually represents the structure of classes and the relationships between them in object-oriented programming.

[1055] An "interface specification" is a document or diagram that details the communication methods and protocols between software components.

[1056] "Feedback" refers to comments and correction requests provided by users.

[1057] "System reliability" refers to the ability of a system to operate stably without failures or errors.

[1058] "Maintainability" refers to the ability of software or systems to be easily changed or updated.

[1059] The present invention is a system for automating the refactoring of old systems and for efficient and stable maintenance and operation. Specifically, the invention is implemented using the following hardware and software.

[1060] Hardware and Software

[1061] Plugins: Software extensions that are installed on the system being refactored.

[1062] SystemAnalyzer: A software class that analyzes program code and network configurations.

[1063] Cloud AI Service: Uses AI models running on the cloud. The endpoint URL is http: / / cloud.service.ai / refactor.

[1064] Data processing and calculation

[1065] First, the user installs a dedicated plugin into the system to be refactored. This plugin is a tool for analyzing the system's code and network configuration. Next, the user specifies the root directory path of the system to be analyzed. Based on this specification, analysis of the program code and network configuration begins.

[1066] The device initializes the SystemAnalyzer class using the specified system path. This class analyzes the code and extracts class diagrams and interface specifications. The analysis results are visualized to reveal internal structures and dependencies.

[1067] The analysis results are sent in JSON format to an AI service on the cloud. The data includes details of each class's functions, methods, fields, and so on. The cloud AI model on the server uses the latest technology and algorithms to generate an optimized code structure based on the received analysis results. This optimization includes the design of new classes and interfaces. The generated structure is then sent back to the device.

[1068] The terminal that receives the optimized structure updates the system code accordingly, replacing old classes and interfaces with new, optimized ones, and providing the analysis results to the user as class diagrams and interface specifications, and receiving user feedback.

[1069] Users can review the provided class diagrams and interface specifications and provide feedback, for example, making specific requests such as "I want X to be added as a method in this new class." Based on the user's feedback, the device will further optimize the code and complete the final refactoring.

[1070] Specific examples

[1071] A company has an inventory management system that was developed 20 years ago. This system is still in operation, but maintenance is becoming difficult due to the complexity of the code and the large number of dependencies. A user specifies the root directory path of this system, installs a plugin, and starts analysis.

[1072] Example prompt sentence:

[1073] Simply specify the root directory path of your old inventory management system to start the analysis, then send the analysis results to our cloud-based AI service to generate an optimized structure.

[1074] The flow of the identification process in the first embodiment will be described with reference to FIG.

[1075] Step 1:

[1076] The user installs a plugin into the system to be refactored. The input is the user clicking the install button. The output is that the plugin installation is complete and the system is ready to analyze program code and network configuration. In this step, the required libraries and modules are added to the system as the plugin is installed.

[1077] Step 2:

[1078] The user specifies the root directory path of the system to be analyzed. The input is that the user enters the path information into an input field. The output is that the path information is correctly recognized and the basic data is set to proceed to the next analysis step. In this step, the user specifies the root path, for example, "C:\OldInventorySystem."

[1079] Step 3:

[1080] The device initializes the SystemAnalyzer class using the specified system path and analyzes the program code and network configuration. The input is the system path specified by the user in step 2. The output is the analysis results, in which class diagrams and interface specifications are extracted. In this step, as the analysis progresses, the inheritance relationships and dependencies of classes are made clear, and the results are visualized visually.

[1081] Step 4:

[1082] The device sends the analysis results to the AI ​​service on the cloud. The input is the analysis results in JSON format obtained in step 3. The output is the start of the optimization process in the cloud AI service. This step includes sending the data to a cloud endpoint (e.g., http: / / cloud.service.ai / refactor) according to a communication protocol.

[1083] Step 5:

[1084] The cloud AI model on the server generates an optimized code structure based on the received analysis results. The input is the analysis results sent in step 4. The output is the generation of an optimized code structure, which is sent back to the device. In this step, the AI ​​model uses the latest technologies and algorithms to remove redundant code and design new class interfaces.

[1085] Step 6:

[1086] The terminal updates the system code based on the optimized structure received from the cloud. The input is the optimized code structure returned in step 5. The output is the updated system code and visually visualized class diagrams and interface specifications. In this step, new classes and interfaces replace the old ones, and the analysis results are provided to the user.

[1087] Step 7:

[1088] The user checks the provided class diagram and interface specifications and sends feedback. The input is the analysis results and specification diagram provided in step 6. The output is specific suggestions and correction requests from the user. In this step, the user sends feedback to the terminal, such as "I would like X to be added as a method of this new class."

[1089] Step 8:

[1090] The terminal further modifies the optimized code based on user feedback and completes the final refactoring. The input is the feedback received from the user in step 7. The output is the final modified system code. In this step, the code is manually modified based on the feedback, and the system is fully updated.

[1091] (Application example 1)

[1092] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1093] Currently, industrial equipment control systems are used for long periods of time, resulting in outdated software and often difficult maintenance. This necessitates highly efficient and stable refactoring of these systems. However, manual refactoring is time-consuming and prone to errors. Furthermore, because proper refactoring requires specialized knowledge, there is a serious shortage of human resources. Further challenges arise when portable terminals are required for operation on-site, such as in factories.

[1094] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[1095] In this invention, the server includes means for analyzing program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the acquired optimized code structure, and means for refactoring the control system for industrial equipment and operated by a portable terminal. This enables efficient refactoring of the control system for industrial equipment such as factory robots, and realizes automated maintenance and stable operation.

[1096] "Generated artificial intelligence" refers to a model trained using existing technology that has the ability to analyze and optimize program code and network configurations.

[1097] "Program code" is a set of instructions containing specified algorithms and structures that direct the operation of a computer system.

[1098] A "network configuration" is the layout and configuration of the physical and logical connections that computer systems use to communicate.

[1099] The "cloud" is a collection of resources, services, and data storage provided over the internet, and is a data center with the ability to store, process, and optimize analytical results.

[1100] "Code structure" is the design and organizational form of program code, showing the relationships between classes, methods, and interfaces.

[1101] "Industrial equipment" is a general term for machinery and equipment used in production and processing processes, including their control systems.

[1102] A "control system" is a combination of software and hardware used to monitor and direct the operation of industrial equipment and other devices.

[1103] "Refactoring" is the process of redesigning the internal structure of a current system without changing its external behavior, thereby improving its efficiency and maintainability.

[1104] "Portable terminal" means a device that can be carried around and used for operation and display of data. This includes tablets and smartphones.

[1105] A "class diagram" is a visual diagram used in object-oriented design that shows a system's classes and their relationships.

[1106] An "interface specification" is a document that defines the standard protocols and methods for different systems or components to communicate with each other.

[1107] "Feedback" refers to opinions and information provided by end users regarding their usage experience and areas for improvement, which are useful for optimizing the system.

[1108] This invention is a highly efficient and stable system for refactoring industrial equipment control systems. This system consists of the following major components: means for analyzing program code and network configurations using generated artificial intelligence, means for transmitting the analysis results to the cloud and obtaining an optimized code structure, means for automatically updating the program code based on the obtained optimized code structure, and means for being operated by a portable terminal.

[1109] Hardware and software used

[1110] Hardware:

[1111] Portable devices such as smartphones and tablets

[1112] Industrial equipment used in factories

[1113] software:

[1114] Refactoring System Plugin

[1115] Cloud AI Service (http: / / cloud.service.ai / refactor)

[1116] Class diagram and interface specification visualization tool

[1117] Program processing explanation

[1118] 1. The user installs the refactoring system plugin into the control system of the target industrial equipment.

[1119] 2. The user specifies the root directory path of the control system using the portable terminal.

[1120] 3. Based on the specified path, the terminal initializes the SystemAnalyzer class and analyzes the program code and network configuration. This analysis generates a class diagram and interface specifications.

[1121] 4. The device sends the analysis results in JSON format to the cloud-based AI service. The cloud AI model generates an optimized code structure based on the analysis results and sends it back to the device.

[1122] 5. The terminal receives the optimized code structure and automatically updates the control system program code accordingly. Engineers can review class diagrams and interface specifications on the portable terminal and provide feedback as needed.

[1123] 6. The terminal receives user feedback, further modifies the optimization code, and completes the final refactoring.

[1124] Specific examples

[1125] For example, an engineer visiting an industrial facility to maintain its control system can install a refactoring system plug-in on their smartphone. By specifying the root directory path of the control system, the program code and network configuration are automatically analyzed, and an AI model running on the cloud generates an optimized code structure. The engineer can then update the control system with the optimized code and provide feedback to stabilize the system's operation.

[1126] Example prompt sentence:

[1127] Analyze the control system code of an industrial device and generate an optimized structure based on the latest technology. Below is the analysis result of the system code class diagram and interface specification:

[1128] Class diagram: [insert class diagram here]

[1129] Interface Specification: [insert interface specification here]

[1130] Requirements: Optimize the operation of the system by designing new classes and interfaces and removing redundant code.

[1131] Through this process, the refactoring of industrial equipment control systems is automated, significantly improving maintenance and operational efficiency.

[1132] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[1133] Step 1:

[1134] The user installs the refactoring system plugin into the control system of the target industrial equipment. The input is the hardware and software environment of the control system connected to the industrial equipment. This gives the terminal access to the control system.

[1135] Step 2:

[1136] The user specifies the root directory path of the control system using a portable terminal (smartphone or tablet). The input is the file path specified by the user. The terminal obtains the program code and network configuration of the control system based on the specified path.

[1137] Step 3:

[1138] The terminal initializes the SystemAnalyzer class and analyzes the acquired program code and network configuration. The input is the file in the specified root directory path and network configuration information. As a result of the analysis, a class diagram and interface specifications are generated. The output is the class diagram and interface specifications as the analysis results.

[1139] Step 4:

[1140] The device sends the analysis results in JSON format to the AI ​​service on the cloud. The input is the analysis results generated in the previous step. This data is sent to the cloud. The cloud AI model on the server receives it and generates an optimized code structure. The output is the optimized code structure.

[1141] Step 5:

[1142] The cloud AI model generates an optimized code structure and sends it back to the device. The input is the cloud's data calculation and optimization algorithm based on the analysis results. The output is JSON data containing the optimized code structure.

[1143] Step 6:

[1144] The terminal receives the optimized code structure and automatically updates the program code of the control system based on it. The input is the optimized code structure sent from the server. The terminal updates the program code of the control system and implements new classes and interfaces. The output is the updated program code of the control system.

[1145] Step 7:

[1146] The user checks the class diagram and interface specifications on a portable terminal and provides feedback as needed. The input is the class diagram and interface specifications based on the optimized and updated program code. The output is the feedback from the user.

[1147] Step 8:

[1148] The device receives user feedback and further refines the optimized code. The input is the user feedback information. If necessary, it again connects with the cloud AI service to optimize the code and complete the final refactoring. The output is the final optimized program code.

[1149] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1150] This invention relates to a system that uses generated artificial intelligence to analyze the program code and network configuration of old systems and automate refactoring. Furthermore, by combining it with an emotion engine that recognizes user emotions, feedback is effectively reflected and the system is optimized.

[1151] Explanation of program processing

[1152] First, the user installs the plugin into the old system to be refactored, then the user specifies the root directory path of the system, which then starts analyzing the system's code and network configuration.

[1153] The terminal initializes the SystemAnalyzer class using the specified system path. This is the process of analyzing the program code of the target system and extracting class diagrams and interface specifications. The analysis results are visualized to clarify the internal structure and dependencies.

[1154] Next, the device sends the analysis results to an AI service on the cloud. The cloud service endpoint uses a pre-configured URL (e.g., http: / / cloud.service.ai / refactor). The analysis results are sent to the cloud in JSON format, and the generated AI on the cloud uses this to generate an optimized code structure.

[1155] The cloud AI service on the server performs refactoring based on the submitted code structure. The server then analyzes the received analysis results using its internal AI model and generates optimization suggestions, such as reviewing dependencies between classes and removing redundant code.

[1156] The terminal that receives the optimized structure updates the system code based on it, replacing old classes and interfaces with new, optimized ones. It also provides the results of the program code analysis to the user as class diagrams and interface specifications, and receives feedback from the user.

[1157] Here, an emotion engine is incorporated into the user feedback. The device collects the user's emotion data via the emotion engine and sends it along with the feedback to a cloud service. The emotion data is used to gain a deeper understanding of the user's satisfaction and problems.

[1158] The server readjusts optimization suggestions based on the emotional data and further improves the code. For example, if a part of the code where the user is feeling stressed is identified, that part will be prioritized for optimization. In addition, for parts with a lot of positive emotional data, suggestions will be made to maintain that state.

[1159] Finally, the device updates the system based on the optimized code received from the cloud service and notifies the user, thereby achieving effective refactoring that takes user sentiment into account.

[1160] This system enables more appropriate and efficient system optimization by incorporating user emotional feedback into the automated refactoring process. Specifically, it identifies system improvements based on user emotional data and incorporates them into the system, thereby improving user satisfaction and system stability.

[1161] The processing flow will be explained below.

[1162] Step 1:

[1163] The user installs the plugin into the old system that is to be refactored.

[1164] How it works: Users download the plugin file from the official website or designated repository, install it in their system environment, and follow the installation instructions to install the plugin into their system with administrator privileges.

[1165] Step 2:

[1166] The user specifies the root directory path of the system to be refactored.

[1167] Specific operation: The user edits a configuration file or specifies the root directory path of the target system (e.g., / path / to / legacy / system) using a command line argument.

[1168] Step 3:

[1169] The device will initialize the SystemAnalyzer class using the specified system path.

[1170] Specific operation: The terminal creates an instance of the SystemAnalyzer class and sets the specified system path in the __init__() method, which determines the location of the system code to be analyzed.

[1171] Step 4:

[1172] The device uses the SystemAnalyzer class to analyze the system code.

[1173] Specific operation: The terminal calls the analyze_code() method of SystemAnalyzer, and internally uses the _parse_code() method to read the code file and extract class and interface information. The code structure is visually visualized as a class diagram and interface specification.

[1174] Step 5:

[1175] The device sends the analysis results to an AI service on the cloud.

[1176] Specific operation: The device converts the analysis results into JSON format and sends them to the cloud AI service endpoint (e.g., http: / / cloud.service.ai / refactor) via a POST request.

[1177] Step 6:

[1178] The cloud AI service on the server performs refactoring based on the submitted code structure.

[1179] Specific operation: The server analyzes the received analysis results using an AI model and generates optimization suggestions, such as reviewing dependencies between classes and removing redundant code.

[1180] Step 7:

[1181] The server generates an optimized code structure and returns it to the terminal.

[1182] Specific operation: The server generates the optimized code structure in JSON format and returns it to the device through an HTTP response, allowing the device to receive the optimization information.

[1183] Step 8:

[1184] The terminal updates the system based on the optimized code structure.

[1185] Specific operation: The device automatically updates the system code based on the optimized structure received from the cloud AI service, specifically replacing outdated classes and interfaces with new, optimized ones.

[1186] Step 9:

[1187] The terminal notifies the user that the system update is complete.

[1188] Specific operation: Once the update is complete, the device will notify the user via the command line or log that "refactoring is complete."

[1189] Step 10:

[1190] The device uses an emotion engine to collect user feedback.

[1191] Specific operation: The device collects emotional data such as facial expressions and voice from the user through the emotion engine, analyzes the data, identifies the user's emotional state (e.g., satisfaction, dissatisfaction, stress), and generates feedback based on that.

[1192] Step 11:

[1193] The device sends feedback along with emotional data to a cloud AI service.

[1194] Specific operation: The device converts the emotional data from the user into JSON format and sends it along with the analysis results to the cloud AI service endpoint via a POST request.

[1195] Step 12:

[1196] The server readjusts the optimization suggestions based on the emotional data.

[1197] Specific operation: The server analyzes the received emotional data and adjusts optimization suggestions based on the user's emotional state. For example, it prioritizes optimization of areas that cause stress, and makes suggestions to maintain the state of areas with a lot of positive emotional data.

[1198] Step 13:

[1199] The server sends the re-adjusted optimization proposal back to the device.

[1200] Specific operation: The server generates the retuned optimized structure in JSON format and returns it to the terminal via an HTTP response.

[1201] Step 14:

[1202] The device will update the system again and notify the user again.

[1203] Specific operation: The terminal updates the system code based on the re-adjusted optimization structure and finally notifies the user that "refactoring is complete."

[1204] Example 2

[1205] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1206] In the current system, refactoring old program code and network configurations requires a great deal of time and effort, and there is a significant lack of automation. Furthermore, there is no way to fully incorporate user feedback, which hinders efficient system improvements. Furthermore, there is no mechanism for utilizing user emotional data, making it difficult to improve satisfaction.

[1207] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[1208] In this invention, the server includes means for analyzing program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the acquired optimized code structure, means for collecting feedback from users and analyzing their emotional data to adjust optimization proposals, and means for automatically updating the code again based on the optimization proposals generated by the cloud service. This enables automation and efficiency of refactoring work, and realizes advanced system optimization that takes user feedback and emotional data into consideration.

[1209] "Generated artificial intelligence" refers to machine learning models that are designed and trained to perform specific tasks.

[1210] "Program code" means a sequence of instructions for a computer to carry out.

[1211] A "network configuration" is the design and layout of how multiple computers or devices are connected to exchange information.

[1212] "Means for analysis" refers to means for identifying and understanding the internal structure and dependencies of program code and network configurations.

[1213] "Code structure to be optimized" refers to the design of program code that should be restructured for the purpose of improving performance and maintainability.

[1214] "Automatic update means" refers to a means by which a system or program automatically applies new code without human intervention.

[1215] "User feedback" refers to opinions and impressions provided by users of a system or service.

[1216] The "means for analyzing emotion data and adjusting optimization suggestions" refers to a means for changing the system's optimization suggestions based on the user's emotions.

[1217] "Cloud services" refer to computing resources and platforms provided over the Internet.

[1218] "Optimization proposals" are specific improvement measures to improve system performance and user experience.

[1219] This invention is a system that uses generated artificial intelligence to analyze the program code and network configuration of old systems and automate refactoring. Furthermore, by combining it with an emotion engine that recognizes user emotions, it effectively reflects feedback and optimizes the system.

[1220] The system uses the following hardware and software:

[1221] Hardware: Terminals, servers, cloud computing environments

[1222] Software: Plug-ins, emotion engines, code analysis software, cloud AI services

[1223] First, the user installs the plugin on the old system to be refactored. Next, the user specifies the root directory path of the system. For example, if the user specifies / path / to / old / system, this path will become the target of analysis. After this operation, the system's code and network configuration will be analyzed.

[1224] Specifically, the terminal initializes the SystemAnalyzer class using the specified system path. This class analyzes the program code of the target system and extracts class diagrams and interface specifications. The analysis results are visualized to clarify the internal structure and dependencies. The visualization results are provided, for example, as a web-based dashboard.

[1225] For example, run the analysis using the following prompt:

[1226] Prompt: "Please analyze the code and network structure of the system located at / path / to / old / system"

[1227] The device then sends the analysis results to an AI service on the cloud. The cloud service endpoint is pre-configured, for example, http: / / cloud.service.ai / refactor. The analysis results are sent to the cloud in text format rather than JSON format, and the AI ​​generated on the cloud uses this to generate an optimized code structure. During this process, AST (Abstract Syntax Tree) analysis is performed, and the internal structure and dependencies of the code are analyzed in detail.

[1228] For example, send the following prompt to the server:

[1229] Prompt: "Optimize the following code structure: Example class with method"

[1230] The cloud AI service on the server performs refactoring based on the received analysis results. Specifically, it reviews dependencies and removes redundant code. The generated optimization suggestions are returned to the device from the cloud AI service.

[1231] The terminal updates the system code based on the optimized code structure, replacing old classes and interfaces with new, optimized ones, and provides the results of the program code analysis to the user as class diagrams and interface specifications, and receives user feedback.

[1232] The device collects user emotional data via an emotion engine. For example, if a user finds a particular piece of code "difficult," that emotional data is collected as feedback and sent to a cloud service. This data is analyzed to identify user satisfaction and dissatisfaction.

[1233] The server then readjusts optimization suggestions based on the emotional data. For example, if it identifies areas where the user is feeling stressed, it generates suggestions to prioritize optimizing those areas of code. Additionally, if areas have a lot of positive emotional data, it makes suggestions to maintain that state.

[1234] Finally, the device updates the system based on the optimized code received from the cloud service and notifies the user. This process achieves effective refactoring that takes user sentiment into account.

[1235] As described above, the present invention realizes automation and efficiency of refactoring work, and further provides advanced system optimization that takes into account user feedback and emotional data.

[1236] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1237] Step 1:

[1238] The user installs a plugin into the old system to be refactored. Specifically, the user introduces a dedicated plugin into the system environment and verifies that it is initialized correctly. The input requires the installation directory of the old system and the plugin installation file, and the output is a state in which the plugin has started working correctly.

[1239] Step 2:

[1240] The user specifies the system root directory path, for example, / path / to / old / system using an interactive input window or command line. This path information is required as input, and this path is recorded as the target for analysis as output.

[1241] Step 3:

[1242] The device initializes the SystemAnalyzer class using the specified system path. This class has the ability to analyze program code and network configuration. Specific operations begin by reading the source code in the directory and then analyzing it to extract class diagrams and interface specifications. The source code in the specified path is required as input, and the resulting abstract syntax tree (AST) and dependency data are generated as output.

[1243] Step 4:

[1244] The device converts the analysis results into JSON format and sends them to the AI ​​service on the cloud. The destination is a pre-configured URL (e.g., http: / / cloud.service.ai / refactor). Specifically, the analysis results are serialized and sent to the cloud via an HTTP POST request. The input is the analysis results generated in the previous step, and the output is a successful submission status.

[1245] Step 5:

[1246] The cloud AI service on the server performs refactoring based on the received JSON data. It uses a generative AI model to restructure dependencies and perform optimizations such as removing redundant code. Specifically, the AI ​​analyzes the code and proposes improvements. The input to this process is JSON data, and the output is an optimized code structure.

[1247] Step 6:

[1248] The device receives the optimized code structure from the cloud AI service and updates the system code accordingly. Specifically, the old source code is replaced with the new, optimized code. The optimized code structure data is required as input, and the updated system code is obtained as output.

[1249] Step 7:

[1250] The terminal visualizes the analysis results of the program code and the optimized code as class diagrams and interface specifications and provides them to the user. Specifically, it uses a visualization tool to illustrate the class diagrams and interface specifications, which the user can view. The input is the analysis results and the optimized code, and the output is the visualized class diagrams and interface specifications.

[1251] Step 8:

[1252] The device uses an emotion engine to collect user feedback, such as capturing and analyzing user thoughts and emotions about a specific piece of code as text or voice. User feedback data is required as input, and emotion data is obtained as output.

[1253] Step 9:

[1254] The server readjusts the optimization suggestions based on the emotional data. Specifically, it prioritizes refactoring areas where users found it difficult and keeps areas that have received a lot of positive feedback. The input to this process is the emotional data, and the output is the readjusted optimization suggestions.

[1255] Step 10:

[1256] The device updates the system based on the optimized code received from the cloud service and notifies the user of the final result. Specifically, it applies the updated source code and reports the changes to the user. The input is the retuned optimized code, and the output is the updated system code and a notification message.

[1257] (Application example 2)

[1258] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1259] Robot systems in modern factories rely on complex program code and network configurations, but these systems become redundant over time and require optimization. Furthermore, traditional refactoring methods for periodic maintenance are performed manually, which is time-consuming, labor-intensive, and prone to errors. Furthermore, it is difficult to effectively incorporate operator feedback, making it difficult to improve usability and ensure system stability.

[1260] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[1261] In this invention, the server includes means for analyzing program code and network configuration using the generated artificial intelligence, means for transmitting the analysis results to the cloud and acquiring the code structure to be optimized, means for automatically updating the program code based on the optimized code structure, means for collecting feedback, and means for readjusting the optimization proposal based on the collected feedback and emotion data, thereby enabling effective refactoring of the factory robot system and continuous optimization that takes into account the emotions of the operators.

[1262] "Generated AI" refers to AI created using technologies such as machine learning and deep learning.

[1263] "Program code" refers to source code written to cause a computer to perform a specific operation.

[1264] A "network configuration" is a structure that shows the connections and arrangement of devices within a computer network.

[1265] "Optimized code structure" refers to the structure of program code that has been improved and optimized based on the analysis results.

[1266] A "feedback collection means" refers to a method or device for collecting information such as opinions, impressions, and feelings from users.

[1267] "Emotion data" refers to data that indicates the user's emotional state, including information that identifies, for example, joy, anger, sadness, etc.

[1268] "Optimization proposals" are proposals for improving program code and system configuration based on analysis results, feedback, and emotional data.

[1269] This invention describes an automated refactoring system applicable to factory robots. This system uses a generative AI model to analyze program code and network configurations and propose optimized code. Furthermore, it analyzes user sentiment data and reflects it in the optimization proposals, improving the system's efficiency and usability.

[1270] System Configuration

[1271] 1. Hardware:

[1272] Factory robot terminal: industrial computer

[1273] Server: A computer server on the cloud

[1274] Feedback collection devices: devices with emotion engines (e.g. emotion recognition cameras)

[1275] 2. Software:

[1276] emotion_engine library: A library for recognizing operator emotions

[1277] ai_refactor_service library: A library for working with cloud AI services

[1278] Analysis software: Software that analyzes program code and network configuration

[1279] Program processing explanation

[1280] The device first analyzes the program code and network configuration to be refactored. From this analysis, class diagrams and interface specifications are extracted and visualized. The analysis results are then sent to an AI service (ai_refactor_service library) on the cloud, which then generates optimization code suggestions.

[1281] The device that receives the optimization proposal automatically updates its program code based on the optimization code structure obtained from the cloud.

[1282] Furthermore, the terminal uses an emotion engine (emotion_engine library) to collect feedback and emotional data from the operator while working, allowing it to grasp the user's satisfaction and stress points in real time and send this information to a cloud AI service.

[1283] The server then adjusts the optimization suggestions based on the received feedback and emotional data. For example, it can prioritize optimizing code that causes stress to the user. The adjusted optimization code is then sent to the device, where it updates the system.

[1284] Specific examples

[1285] As a concrete example, consider a factory robot that manufactures certain automotive parts. During scheduled maintenance, the factory robot refactors the system. The analyzed program code and network configuration are sent to a cloud AI service, which generates optimization suggestions. The robot also collects operator sentiment data, which is used to further refine the optimization process.

[1286] Prompt Sentence Examples

[1287] "Submit the results of your code analysis. Generate optimization suggestions."

[1288] "This is operator sentiment data and feedback. Please use this to improve the code."

[1289] As described above, the system of the present invention not only automatically refactors the program code of factory robots, but also enables continuous optimization based on operator emotion data, thereby realizing efficient and user-friendly factory operations.

[1290] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1291] Step 1:

[1292] The device collects the program code and network configuration to be refactored. It takes the user-specified system path as input, reads the system's program code based on this path, and analyzes the network configuration. This code and network information are stored as internal data structures.

[1293] Step 2:

[1294] The terminal analyzes the collected program code and network configuration. The input for this analysis is the code and network information collected in step 1, and the output is analysis results such as class diagrams and interface specifications. The analysis results are then clearly visualized using the SystemAnalyzer class to reveal internal structures and dependencies.

[1295] Step 3:

[1296] The device sends the analysis results to an AI service on the cloud. Here, the analysis results are sent in JSON format to an endpoint (e.g., http: / / cloud.service.ai / refactor). The input is the analysis results obtained in step 2, and the cloud-based AI service generates optimization suggestions based on this. The optimized code structure is returned as the output.

[1297] Step 4:

[1298] The server performs refactoring based on the analysis results received from the cloud. It performs analysis using an internal AI model, for example, reviewing dependencies between classes and removing redundant code. The input is the analysis results sent in step 3, and the output is optimized program code.

[1299] Step 5:

[1300] The terminal automatically updates the program code based on the optimized code received from the server. This process involves replacing old classes and interfaces with new, optimized ones. The input is the optimized code received in step 4, and the output is the updated program code.

[1301] Step 6:

[1302] The terminal uses an emotion engine to collect operator feedback and emotion data. Emotional information is acquired in real time while the user is working and collected through a feedback device. The input is the emotion information sensed while the user is working, and the output is emotion data and feedback from the user.

[1303] Step 7:

[1304] The device sends the collected feedback and emotion data to the cloud AI service. Here, the emotion data and feedback obtained by the feedback device are sent in JSON format to an endpoint (e.g., http: / / cloud.service.ai / feedback). The input is the emotion data and feedback obtained in step 6, and the cloud-side AI service generates further optimization suggestions based on this.

[1305] Step 8:

[1306] The server readjusts the optimization proposal based on the received feedback and emotional data, performing operations such as prioritizing optimization of areas where the user felt stressed, and generates the final optimization proposal. The input is the feedback and emotional data sent in step 7, and the output is the readjusted optimization code.

[1307] Step 9:

[1308] The terminal receives the final optimization code and performs the final update of the program code based on it. This process involves the same operations as in step 5, and updates the system with the re-adjusted optimization code. The input is the optimization code received in step 8, and the output is the final updated program code.

[1309] 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 control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

[1310] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1311] In the above embodiment, an example in which the specific processing is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the robot 414.

[1312] The emotion identification model 59 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 an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1313] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1314] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1315] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1316] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1317] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs 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 a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1318] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1319] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1320] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

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

[1322] 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.

[1323] It is not necessary to store all 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 all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1324] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1325] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with 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). Also, the hardware resource that executes the specific processing may be a single processor.

[1326] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1327] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1328] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1329] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1330] The following is further disclosed regarding the above embodiment.

[1331] (Claim 1)

[1332] A means for analyzing program code and network configuration using the generated artificial intelligence;

[1333] a means for transmitting the analysis results to the cloud and obtaining the code structure to be optimized;

[1334] means for automatically updating the program code based on the obtained optimized code structure;

[1335] A system including:

[1336] (Claim 2)

[1337] 10. The system of claim 1, further comprising means for visualizing the results of the analysis of the program code as a class diagram and an interface specification.

[1338] (Claim 3)

[1339] 10. The system of claim 1, further comprising means for receiving feedback from a user and further modifying the optimization code based thereon.

[1340] "Example 1"

[1341] (Claim 1)

[1342] A means to install the plugin on the system to be refactored and specify the system path.

[1343] A means for analyzing program code and network configuration using the generated artificial intelligence;

[1344] a means for transmitting the analysis results to the cloud and obtaining the code structure to be optimized;

[1345] means for automatically updating the program code based on the obtained optimized code structure;

[1346] A means to provide class diagrams and interface specifications to users and receive feedback from them.

[1347] A system including:

[1348] (Claim 2)

[1349] 10. The system of claim 1, further comprising means for visualizing the results of the analysis of the program code as a class diagram and an interface specification.

[1350] (Claim 3)

[1351] 10. The system of claim 1, further comprising means for receiving feedback from a user and further modifying the optimization code based thereon.

[1352] "Application Example 1"

[1353] (Claim 1)

[1354] A means for analyzing program code and network configuration using the generated artificial intelligence;

[1355] a means for transmitting the analysis results to the cloud and obtaining the code structure to be optimized;

[1356] means for automatically updating the program code based on the obtained optimized code structure;

[1357] means for refactoring a control system for an industrial device, the means being operated by a portable terminal;

[1358] A system including:

[1359] (Claim 2)

[1360] 10. The system of claim 1, further comprising means for visualizing the results of the analysis of the program code as a class diagram and an interface specification.

[1361] (Claim 3)

[1362] 10. The system of claim 1, further comprising means for receiving feedback from a user and further modifying the optimization code based thereon.

[1363] "Example 2: Combining Emotion Engines"

[1364] (Claim 1)

[1365] A means for analyzing program code and network configuration using the generated artificial intelligence;

[1366] a means for transmitting the analysis results to the cloud and obtaining the code structure to be optimized;

[1367] means for automatically updating the program code based on the obtained optimized code structure;

[1368] a means of collecting user feedback and analyzing the sentiment data to adjust optimization suggestions;

[1369] A means for automatically updating the code again based on optimization suggestions generated by the cloud-based service; and

[1370] A system including:

[1371] (Claim 2)

[1372] 10. The system of claim 1, further comprising means for visualizing the results of the analysis of the program code as a class diagram and an interface specification.

[1373] (Claim 3)

[1374] 10. The system of claim 1, further comprising: means for further modifying the optimization code based on the user's emotional data.

[1375] "Application example 2 when combining emotion engines"

[1376] (Claim 1)

[1377] A means for analyzing program code and network configuration using the generated artificial intelligence;

[1378] a means for transmitting the analysis results to the cloud and obtaining the code structure to be optimized;

[1379] means for automatically updating the program code based on the obtained optimized code structure;

[1380] a feedback collection means;

[1381] A means to readjust optimization suggestions based on collected feedback and sentiment data; and

[1382] A system including:

[1383] (Claim 2)

[1384] 10. The system of claim 1, further comprising means for visualizing the results of the analysis of the program code as a class diagram and an interface specification.

[1385] (Claim 3)

[1386] 10. The system of claim 1, further comprising means for receiving feedback and sentiment data from a user and further modifying the optimization code based thereon. [Explanation of symbols]

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

Claims

1. A means for analyzing program code and network configuration using the generated artificial intelligence; a means for transmitting the analysis results to the cloud and obtaining the code structure to be optimized; means for automatically updating the program code based on the obtained optimized code structure; A system including:

2. The system of claim 1 , further comprising means for visualizing the results of the analysis of the program code as a class diagram and an interface specification.

3. The system of claim 1 , further comprising means for receiving feedback from a user and further modifying the optimization code based thereon.

Images