system

Abstract

We provide the system. [Solution] A device for collecting source code, A device that analyzes the aforementioned source code to identify commercial program components, A device that recommends open-source programs to replace the aforementioned commercial program components, A device that automatically converts the source code using the aforementioned recommended open-source program, A device for verifying that the converted source code functions correctly, A device including means for remotely monitoring software progress within a data center, A system that includes this.

Description

Technical Field

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

Background Art

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

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] In the current situation where the license cost of commercial software is a heavy burden for enterprises, a rapid migration to new technologies or open source software (OSS) is essential to reduce technical debt and maintain competitiveness. However, the task of analyzing the code of existing software and identifying and replacing appropriate OSS requires specialized knowledge and consumes a large amount of time and resources. Against this background, there is a need for an automated means that enables enterprises to migrate from commercial software to OSS efficiently and effectively.

Means for Solving the Problems

[0005] This invention solves the above problems by providing means for acquiring source code, performing code analysis, and automatically identifying commercial software components. Furthermore, it includes means for automatically suggesting the most suitable OSS that can replace the identified commercial software components and for automatically converting the code based on that suggestion, thereby achieving efficient migration. In addition, it provides a system for safely and quickly migrating to OSS by including testing means to ensure that the converted code functions correctly.

[0006] "Source code" is a form of text that can be understood by the person who wrote the computer program, and it is constructed using a programming language.

[0007] "Analysis" is the act of breaking down information or data into its constituent elements, structure, and characteristics.

[0008] A "commercial software component" is a part or module of software that is sold for a fee and is designed to provide a specific function.

[0009] Open-source software (OSS) is software whose source code is made public and which is licensed in a way that allows for free use, modification, and distribution.

[0010] A "proposal" is the act of presenting solutions or options for a specific purpose or need.

[0011] "Transformation" is the operation of replacing one form or structure with another.

[0012] "Testing" is a procedure to verify whether software performs its intended function. [Brief explanation of the drawing]

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

[0014] Hereinafter, an example of an embodiment of the system relating to the technology of this disclosure will be described with reference to the attached drawings.

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

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

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

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

[0019] In the following embodiments, the labeled communication I / F (Interface) is an interface including a communication processor and 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), or Bluetooth (registered trademark), and the like.

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

[0021] [First Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0034] This invention is an AI agent system that efficiently replaces a company's existing software with open-source software. First, when a user uses this system, the existing source code that depends on commercial software is input into the system. Based on this, the server automatically analyzes the entire program and identifies the commercial software components.

[0035] After analysis, the server uses a generative AI to search for open-source software that can replace the identified commercial software. The selection process considers performance, compatibility, and licensing conditions to propose the most suitable alternative. Once this proposal is finalized, the server automatically converts the relevant code into open-source software.

[0036] After the conversion process is complete, the server runs unit and integration tests on the converted source code to ensure it functions the same way as the original program. Once the functionality check is complete, the terminal reports the completion of the migration and its results to the user. For example, when the server converts a commercial database library to an open-source PostgreSQL library, it efficiently optimizes the program by automatically making necessary query modifications and configuration changes.

[0037] This system allows users to quickly and reliably migrate to open-source software (OSS) without requiring particularly deep technical knowledge.

[0038] The following describes the processing flow.

[0039] Step 1:

[0040] The server retrieves the source code specified by the user from the repository. This includes cloning and downloading over the network.

[0041] Step 2:

[0042] The server uses code analysis tools to thoroughly analyze the retrieved source code. During this process, it checks for the presence of commercial software components and maps dependencies and structure.

[0043] Step 3:

[0044] Based on the analysis results, the server uses a generative AI to search for suitable open-source software candidates. Selection criteria include performance, compatibility, and licensing conditions.

[0045] Step 4:

[0046] The server selects the most suitable open-source software from the proposed candidates and performs code conversion to replace commercial software components with it. Function calls and configuration file modifications are also made.

[0047] Step 5:

[0048] The server runs unit and integration tests to verify that the converted source code functions correctly. This ensures that each function is implemented accurately.

[0049] Step 6:

[0050] The terminal presents the user with a report detailing the conversion results and test success. The report includes information on which commercial software was replaced and the expected cost savings and performance improvements as a result.

[0051] (Example 1)

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

[0053] Migrating programs that rely on existing commercial software to open-source software is a time-consuming and specialized task for many developers. This process requires selecting the right open-source software, replacing the commercial software, and verifying the functionality of the replacement code, often resulting in errors and inefficiencies. Furthermore, selecting open-source software requires considering performance, compatibility, and licensing terms, necessitating an efficient and automated migration method that takes these factors into account.

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

[0055] In this invention, the server includes means for collecting code, means for analyzing the code and identifying commercial program elements, and means for recommending open access programs while considering selection criteria using a generative artificial intelligence model. This enables even users without specialized knowledge to quickly and accurately migrate from commercial software to open-source software.

[0056] "Means of collecting code" refers to devices or methods for collecting program source code and incorporating it into a management system.

[0057] "Means of analyzing code and identifying commercial program elements" refers to methods of examining collected code and identifying parts that depend on specific commercial software.

[0058] "A method for recommending open access programs while considering selection criteria using a generative artificial intelligence model" refers to a method that uses artificial intelligence technology to evaluate performance, compatibility, and licensing conditions while presenting the most suitable open-source programs.

[0059] "Commercial program elements" are proprietary software components used through purchase or licensing agreements.

[0060] An "open access program" is software whose source code is publicly available and which is freely permitted to be used, modified, and distributed.

[0061] "Means of modification" refers to methods for automatically rewriting the original code to conform to a new library or program.

[0062] "Verification methods" refer to testing methods used to confirm that the modified code correctly performs the intended function.

[0063] This invention is a system for efficiently migrating existing source code that relies on commercial software to open-source software. The system operates through the interaction of a server, terminal, and user, and achieves the following functions.

[0064] First, the user inputs source code dependent on commercial software into the server via a terminal. The terminal can send the source code in the appropriate format, and this data becomes the system's input information.

[0065] Next, the server analyzes the received source code. Static analysis tools are used for this analysis to identify commercial program elements. In this process, the server utilizes a generative AI model to set selection criteria for the optimal open-source software based on the analyzed information. These criteria include performance, compatibility, and licensing terms.

[0066] After analysis, the server uses a generative artificial intelligence model to recommend open-access programs. Specifically, it provides prompts to the generative AI model to suggest appropriate alternative software. An example of a prompt might be, "Suggest steps to convert existing database API calls to open-source versions."

[0067] After a recommended open-source program is suggested, the server performs an automated code modification. Here, the relevant code is rewritten to the standard open-source version, and related API calls and settings are automatically adjusted.

[0068] Finally, the server performs operational verification on the modified code. Unit tests and integration tests are used to confirm that the code functions correctly. After the tests are complete, the terminal notifies the user of the results and reports that the migration process has been successfully completed.

[0069] This system enables users to migrate from commercial code to open source with high accuracy, reducing overall project costs and increasing flexibility without requiring technical knowledge.

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

[0071] Step 1:

[0072] The user inputs source code via a terminal. The input source code is the entire program, dependent on commercial software. This code is transferred to a server and prepared for analysis as initial data. The output is a notification to the server that input is complete.

[0073] Step 2:

[0074] The server analyzes the received source code. This process uses static analysis tools to identify commercial program elements within the code. The input is the source code received in step 1, and the output is a list of identified commercial software components. Specifically, it detects dependent libraries and APIs.

[0075] Step 3:

[0076] The server uses a generative AI model to select open-source candidates to correspond to commercial program elements. The AI ​​model makes the optimal selection considering performance, compatibility, and licensing conditions. The input is a list of commercial software components obtained in step 2, and the output is a list of alternative open-access programs. Specifically, the AI ​​is given a prompt such as, "Suggest a means to replace a commercial database library with an open-source library."

[0077] Step 4:

[0078] The server automatically modifies the code using the proposed open-access program. The input is the open-source software selected in step 3. It replaces calls to commercial components in the code and automatically adjusts configuration files and APIs accordingly. The output is the modified source code.

[0079] Step 5:

[0080] The server performs tests on the modified source code to verify its functionality. The input is the source code modified in step 4, and the server uses unit and integration tests to verify the program's accuracy. The output is the test results. Specifically, the existing test suite is run to confirm that the output is as expected.

[0081] Step 6:

[0082] After the test is successfully completed, the terminal reports the migration results to the user. The input is the test results obtained in step 5, and the terminal outputs the results as an easy-to-understand report. Specifically, it notifies the user of the success of the migration process and provides the necessary detailed information.

[0083] (Application Example 1)

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

[0085] In corporate data centers and similar environments, efficiently and remotely monitoring the progress of migrations from commercial to open-source programs is difficult. Furthermore, the migration process requires specialized knowledge, and there is a need for methods to facilitate this process.

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

[0087] In this invention, the server includes a device for collecting source code, a device for analyzing the source code and identifying commercial program components, a device for recommending open-source programs to replace the commercial program components, a device for automatically converting the source code with the recommended open-source programs, a device for verifying that the converted source code functions correctly, and means for remotely monitoring software progress within the data center. This enables even users with limited technical knowledge to smoothly transition to open-source programs and remotely monitor their progress.

[0088] "Source code" is a set of instructions written in a human-readable format to define how a computer program works.

[0089] A "device" is a physical or virtual mechanism designed to perform a specific function or task.

[0090] "Commercial program components" refer to parts of software functionality that are provided commercially.

[0091] An "open-source program" is software whose source code is publicly available, allowing anyone to freely use, modify, and distribute it.

[0092] "Recommendation" is the act of presenting the option that is considered most appropriate for a particular purpose.

[0093] "Automatically converting" refers to changing a program or process into another form or function without human intervention.

[0094] "To function correctly" means to operate as designed and produce the expected results.

[0095] A "data center" is a dedicated facility established for the purpose of storing, managing, and distributing data.

[0096] "Remote monitoring" refers to the act of checking operations and situations through information technology, even without being directly present at the location.

[0097] A description of the embodiment for carrying out the invention will be provided.

[0098] This system is a solution for efficiently migrating from commercial programs to open-source programs in enterprise data centers. It is primarily operated via servers and user terminals. The system automates the process of identifying program components and replacing them with open-source programs.

[0099] The server receives source code from the user's terminal and begins analysis to identify components of the commercial program. This analysis includes interpreting dependencies. Once the analysis is complete, the server uses a generative AI model to recommend the most suitable open-source program. This recommendation takes into account performance, compatibility, and usage conditions. The server then automatically converts the source code using the open-source program selected from these options.

[0100] After conversion, the server performs tests to verify that the new program functions correctly. These tests are also automated, and if correct operation is confirmed, the user's terminal is notified of the progress and results.

[0101] This system also allows users to remotely monitor software progress within the data center. Users can check the system's operation from their smart devices via cloud services.

[0102] For example, when replacing new commercial database management software with open-source software, this system can be used to automatically modify all related queries and settings on the server and optimize the program. This allows even administrators with limited technical knowledge to work smoothly.

[0103] An example of a prompt message is: "Describe the steps to convert commercial database software in Company A's data center to open source. Focus particularly on how to remotely monitor the progress of the replacement work."

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

[0105] Step 1:

[0106] The server retrieves the source code from the user's terminal. This source code becomes the input, and the server prepares to analyze the entire program based on it. The purpose of the analysis is to identify the commercial program components contained within the source code.

[0107] Step 2:

[0108] The server analyzes the acquired source code. The analysis process identifies commercial program components and interprets their dependencies. Based on the source code received as input, it constructs an abstract syntax tree and lists the commercial components. This information is used in the next step to select an alternative program.

[0109] Step 3:

[0110] The server uses a generative AI model to recommend open-source programs as alternatives to identified commercial program components. Using the analysis results as input, it generates candidates while considering performance, compatibility, and usage conditions. The output is a list of recommended open-source programs.

[0111] Step 4:

[0112] The server automatically converts source code using recommended open-source programs. The input consists of a list and the original source code, and the server replaces the code based on these. Here, it modifies data structures and API calls as needed to generate new code.

[0113] Step 5:

[0114] The server performs tests on the converted source code. Using the converted code as input, it runs unit and integration tests to verify that the system functions correctly. The output is the test result, which is then reported to the user.

[0115] Step 6:

[0116] Users remotely monitor the progress using their devices. The devices receive notifications and logs from the server, which then display the conversion progress and test results. This allows users to verify that the migration has been successfully completed.

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

[0118] This invention relates to an AI agent system that recognizes user emotions and optimizes tasks during the migration process from commercial software to open-source software. The server first receives source code from the user and analyzes it to identify commercial software components. Then, it uses generative AI to suggest suitable open-source software candidates, while simultaneously acquiring the user's emotions in real time through an emotion engine and dynamically adjusting the suggestions to align with the user's expectations.

[0119] The sentiment engine analyzes how users react to suggestions. For example, if the user is satisfied with the suggested open-source software, the process proceeds as is; if dissatisfied, the suggestion is refined to explore other options. Furthermore, the server automatically converts the code to match the suggestion and then tests the converted code.

[0120] Based on the test results, the emotion engine measures user reactions and analyzes the feedback to improve user satisfaction with the results. The server uses this feedback to continuously improve and incorporate it into future suggestions and transformation processes. For example, when the server replaces a recognized commercial data analysis library in a project the user is involved in with a similar open-source library, it adjusts the presentation of different library candidates based on the user's favorable reactions, efficiently supporting the transition away from commercial licenses.

[0121] In this way, we support the transition to open-source software that reflects user sentiment, and realize a system that improves both efficiency and usability simultaneously.

[0122] The following describes the processing flow.

[0123] Step 1:

[0124] The user accesses the system and uploads the source code to be converted to the server. The server receives it and prepares it for analysis.

[0125] Step 2:

[0126] The server uses analysis tools to perform a detailed analysis of the source code and identify commercial software components. The analysis results include a list of software dependencies and external libraries used.

[0127] Step 3:

[0128] The server uses a generative AI to suggest alternative open-source software based on the analysis results. At this point, an emotion engine is activated to monitor the user's reaction and analyze whether the suggestions are satisfactory.

[0129] Step 4:

[0130] If the user's sentiment is determined to be positive towards the suggestion, the server automatically converts the source code with the suggested open-source software (OSS). If it is negative, the generating AI re-suggests other possible options and re-evaluates the user's satisfaction.

[0131] Step 5:

[0132] The server runs tests on the converted code. These tests include unit tests and integration tests to ensure the code works according to specifications.

[0133] Step 6:

[0134] After the test results are obtained, the device presents the results to the user as feedback. At this time, the emotion engine re-analyzes the user's response, evaluates the final satisfaction level, and collects data on areas for improvement next time.

[0135] Step 7:

[0136] The server uses the collected data to make adjustments to improve the efficiency of subsequent processes. This enables continuous process improvement.

[0137] (Example 2)

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

[0139] The migration process from commercial programs to open-source programs is complex and time-consuming, and can lead to decreased usability and inefficiency because it often proceeds without adequately considering user expectations and feelings. Furthermore, while moving away from commercial licenses is important, calculating the associated risks and costs is difficult. Therefore, a system is needed that enables efficient software migration while reflecting user sentiment.

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

[0141] In this invention, the server includes means for acquiring source code, means for analyzing the source code to identify commercial program components, means for proposing public source programs to replace the commercial program components, means for acquiring the user's emotional state in real time and dynamically adjusting the proposal, means for automatically converting the source code with the proposed public source programs, means for testing that the converted source code operates correctly, and means for analyzing user feedback based on the test results and improving the process. This enables an efficient and effective transition from commercial software to public source software while taking user emotions into consideration.

[0142] "Source code" is a collection of text-based instructions used to describe software or programs, which are then converted into a format that a computer can execute.

[0143] "Commercial program components" refer to parts or all of software that are provided under a commercial license and often incur a fee for use.

[0144] "Open source program" refers to any part or all of software provided under an open-source license that is free to use, modify, and redistribute.

[0145] "User emotional state" refers to the psychological and emotional responses a user exhibits to using a system or proposed software, and is typically measured in real time.

[0146] "Real-time acquisition" means that data and information are collected instantly at the moment processing takes place, and that they are obtained without delay.

[0147] "Dynamic adjustment" refers to a system automatically changing its content and settings in response to changing circumstances to maintain an optimal state.

[0148] "Automatic conversion" refers to a system or program mechanically processing data without human intervention, changing it into a different format or content.

[0149] "Testing for proper operation" refers to a series of verification processes to ensure that software operates as required and delivers the intended results.

[0150] "Analyzing feedback" refers to examining evaluations and opinions provided by users and using them to identify areas for system improvement.

[0151] In this invention, the server obtains source code provided by the user and performs analysis thereon. Here, specific code analysis tools are used to identify commercial program components. For example, general program analysis software may be used to extract source code dependencies.

[0152] After the analysis is complete, the server uses a generative AI model to suggest candidate open-source programs to replace the commercial program. This generative AI model is given instructions such as "Please suggest open-source alternatives to the commercial software currently in use."

[0153] The user's device displays a list of publicly available source programs suggested by the server, and the user makes a selection based on this list. The server can then acquire the user's responses and selections in real time using emotion recognition technology, and dynamically adjust its suggestions. Specifically, to improve user satisfaction, it uses facial recognition cameras and text analysis modules to evaluate the user's emotional state.

[0154] After the user selects candidates for publicly available source programs, the server automatically converts the source code based on these selections. The converted code is then tested in a test environment for functionality verification. A general-purpose testing framework is typically used during this process. This process ensures that all functions work correctly and that the functionality is as expected.

[0155] Finally, the server receives the test results as feedback from the user and analyzes it. Based on the data obtained, it improves future suggestions and the source code conversion process. This feedback process allows for a systematic improvement in user satisfaction.

[0156] This system is designed to facilitate a smooth transition from commercial to open-source programs while reflecting user sentiment, and to improve efficiency and usability.

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

[0158] Step 1:

[0159] The server obtains source code as input from the user. Specifically, the source code is provided via a URL specified by the user or through a file upload. The server records this obtained source code and prepares it for the next analysis step.

[0160] Step 2:

[0161] The server analyzes the acquired source code and identifies commercial program components. It receives the entire source code as input and uses program analysis tools to detect commercial components within the program. This process generates detailed data on dependencies and library usage. The identified commercial components are then utilized in the next proposed step.

[0162] Step 3:

[0163] The server uses a generative AI model to suggest open-source alternatives to commercial programs. Using information on the commercial program components identified as input, and based on the prompt "Suggest open-source alternatives to the commercial software currently in use," the generative AI model outputs candidate open-source programs. The suggested options are then presented to the user.

[0164] Step 4:

[0165] The terminal displays a list of publicly available source programs received from the server to the user. The user reviews the list and makes a selection. Based on the user's selection input, the server records the user's choice.

[0166] Step 5:

[0167] Based on user selection, the server automatically converts the source code. Using the user-selected public source program as input, it replaces commercial components using a code conversion tool. This process generates new source code as the conversion result.

[0168] Step 6:

[0169] The server tests the converted source code in a test environment. It receives the converted source code as input and uses a test framework to verify its operation. Output results are obtained that verify whether the functionality is executed correctly.

[0170] Step 7:

[0171] The server collects and analyzes user feedback based on test results. It takes test results and user ratings as input and uses an emotion engine to assess satisfaction. This analysis generates feedback information useful for future suggestions and process improvements.

[0172] (Application Example 2)

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

[0174] In the migration process from commercial software to open-source software, there is a need to present appropriate alternatives that take user sentiment into consideration, and to carry out the migration work efficiently and satisfactorily. Furthermore, challenges include proposing software that meets user expectations, automating code conversion, and ensuring its accuracy.

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

[0176] In this invention, the server includes means for acquiring source code, means for analyzing the source code to identify commercial software components, means for proposing open-source software to replace the commercial software components, means for acquiring the user's emotional state using emotion recognition means and dynamically adjusting the content of the proposal, means for automatically converting the source code with the proposed open-source software, and means for testing that the converted source code operates correctly. This enables an effective transition to open-source software that takes the user's emotions into consideration.

[0177] "Means of obtaining source code" refers to methods and techniques for obtaining a set of instructions used in the design and development of a program.

[0178] "Means for analyzing source code to identify commercial software components" refers to methods and techniques for thoroughly examining source code, extracting elements of commercially used software from it, and identifying them.

[0179] "Methods for proposing open-source software" refer to methods and technologies for presenting freely available software as an alternative to commercial software.

[0180] "Emotion recognition means" refers to methods and technologies for identifying and understanding a user's emotional state.

[0181] "Means of dynamic adjustment" refer to methods and techniques for automatically changing system or process settings in response to changes in circumstances or conditions.

[0182] "Means of automatic conversion" refers to methods and technologies for converting source code to different formats or specifications without human intervention.

[0183] "Testing methods" refer to the methods and techniques used to perform tests to ensure that source code or programs function correctly.

[0184] To implement this invention, a server-centric system is required. The server first acquires source code provided by the user and identifies commercial software components using the source code analysis platform "LibCST". Based on these identified components, a generative AI model is used to propose alternative open-source software. At this time, emotion recognition technology is used to acquire the user's emotional state in real time, and the open-source options presented by the generative AI are dynamically adjusted based on this data.

[0185] For sentiment recognition, the natural language processing library "TextBlob" is used. This allows sentiment values ​​to be extracted from user feedback and comments. If the proposed open-source software meets user expectations, the server automatically converts the source code. After this automatic conversion process, the server performs testing to verify that the converted code works correctly. The environment used for this testing includes Python and various testing frameworks.

[0186] As a concrete example, consider a system where, when a home robot open-sources software for a music playback service, it detects commercial libraries, suggests alternative open-source libraries through generative AI, and adjusts the candidates based on user feedback. In this process, the generative AI model can be instructed with a prompt such as: "Suggest open-source alternatives for voice recognition software used in home robots."

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

[0188] Step 1:

[0189] The server receives source code from the user. The input is the source code provided by the user, and the output is the source code data to be analyzed. In this process, the system confirms receipt of the source code and prepares to proceed to the next analysis stage.

[0190] Step 2:

[0191] The server uses the "LibCST" library to analyze the received source code and identify commercial software components. The input is the received source code, and the output is a list of commercial software components. Specifically, it generates an AST (Abstract Syntax Tree) to detect where commercial libraries and APIs are used.

[0192] Step 3:

[0193] The server uses a generative AI model to suggest open-source software alternatives to identified commercial software components. It takes a list of commercial software components as input and generates a list of open-source software candidates as output. Prompts are used to instruct the generative AI model and generate the optimal choice.

[0194] Step 4:

[0195] The server acquires the user's emotional state using emotion recognition mechanisms. Input is user feedback and comments, and output is an emotion value. Specifically, the TextBlob library is used to calculate the emotion value from the feedback text, and this information is used to adjust the suggested alternatives.

[0196] Step 5:

[0197] The server automatically converts source code based on the proposed open-source software. The input is information about the selected open-source software and the original source code, and the output is the converted source code. The conversion includes replacing commercial libraries and modifying corresponding code structures.

[0198] Step 6:

[0199] The server uses testing methods to verify that the converted source code works correctly. The input is the converted source code, and the output is the test results. The server ensures the accuracy of the code by checking for bugs and errors in the program and debugging as needed.

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

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

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

[0203] [Second Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0216] This invention is an AI agent system that efficiently replaces a company's existing software with open-source software. First, when a user uses this system, the existing source code that depends on commercial software is input into the system. Based on this, the server automatically analyzes the entire program and identifies the commercial software components.

[0217] After analysis, the server uses a generative AI to search for open-source software that can replace the identified commercial software. The selection process considers performance, compatibility, and licensing conditions to propose the most suitable alternative. Once this proposal is finalized, the server automatically converts the relevant code into open-source software.

[0218] After the conversion process is complete, the server runs unit and integration tests on the converted source code to ensure it functions the same way as the original program. Once the functionality check is complete, the terminal reports the completion of the migration and its results to the user. For example, when the server converts a commercial database library to an open-source PostgreSQL library, it efficiently optimizes the program by automatically making necessary query modifications and configuration changes.

[0219] This system allows users to quickly and reliably migrate to open-source software (OSS) without requiring particularly deep technical knowledge.

[0220] The following describes the processing flow.

[0221] Step 1:

[0222] The server retrieves the source code specified by the user from the repository. This includes cloning and downloading over the network.

[0223] Step 2:

[0224] The server uses code analysis tools to thoroughly analyze the retrieved source code. During this process, it checks for the presence of commercial software components and maps dependencies and structure.

[0225] Step 3:

[0226] Based on the analysis results, the server uses a generative AI to search for suitable open-source software candidates. Selection criteria include performance, compatibility, and licensing conditions.

[0227] Step 4:

[0228] The server selects the most suitable open-source software from the proposed candidates and performs code conversion to replace commercial software components with it. Function calls and configuration file modifications are also made.

[0229] Step 5:

[0230] The server runs unit and integration tests to verify that the converted source code functions correctly. This ensures that each function is implemented accurately.

[0231] Step 6:

[0232] The terminal presents the user with a report detailing the conversion results and test success. The report includes information on which commercial software was replaced and the expected cost savings and performance improvements as a result.

[0233] (Example 1)

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

[0235] Migrating programs that rely on existing commercial software to open-source software is a time-consuming and specialized task for many developers. This process requires selecting the right open-source software, replacing the commercial software, and verifying the functionality of the replacement code, often resulting in errors and inefficiencies. Furthermore, selecting open-source software requires considering performance, compatibility, and licensing terms, necessitating an efficient and automated migration method that takes these factors into account.

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

[0237] In this invention, the server includes means for collecting code, means for analyzing the code and identifying commercial program elements, and means for recommending open access programs while considering selection criteria using a generative artificial intelligence model. This enables even users without specialized knowledge to quickly and accurately migrate from commercial software to open-source software.

[0238] "Means of collecting code" refers to devices or methods for collecting program source code and incorporating it into a management system.

[0239] "Means of analyzing code and identifying commercial program elements" refers to methods of examining collected code and identifying parts that depend on specific commercial software.

[0240] "A method for recommending open access programs while considering selection criteria using a generative artificial intelligence model" refers to a method that uses artificial intelligence technology to evaluate performance, compatibility, and licensing conditions while presenting the most suitable open-source programs.

[0241] "Commercial program elements" are proprietary software components used through purchase or licensing agreements.

[0242] An "open access program" is software whose source code is publicly available and which is freely permitted to be used, modified, and distributed.

[0243] "Means of modification" refers to methods for automatically rewriting the original code to conform to a new library or program.

[0244] "Verification methods" refer to testing methods used to confirm that the modified code correctly performs the intended function.

[0245] This invention is a system for efficiently migrating existing source code that relies on commercial software to open-source software. The system operates through the interaction of a server, terminal, and user, and achieves the following functions.

[0246] First, the user inputs source code dependent on commercial software into the server via a terminal. The terminal can send the source code in the appropriate format, and this data becomes the system's input information.

[0247] Next, the server analyzes the received source code. Static analysis tools are used for this analysis to identify commercial program elements. In this process, the server utilizes a generative AI model to set selection criteria for the optimal open-source software based on the analyzed information. These criteria include performance, compatibility, and licensing terms.

[0248] After analysis, the server uses a generative artificial intelligence model to recommend open-access programs. Specifically, it provides prompts to the generative AI model to suggest appropriate alternative software. An example of a prompt might be, "Suggest steps to convert existing database API calls to open-source versions."

[0249] After a recommended open-source program is suggested, the server performs an automated code modification. Here, the relevant code is rewritten to the standard open-source version, and related API calls and settings are automatically adjusted.

[0250] Finally, the server performs operational verification on the modified code. Unit tests and integration tests are used to confirm that the code functions correctly. After the tests are complete, the terminal notifies the user of the results and reports that the migration process has been successfully completed.

[0251] This system enables users to migrate from commercial code to open source with high accuracy, reducing overall project costs and increasing flexibility without requiring technical knowledge.

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

[0253] Step 1:

[0254] The user inputs source code via a terminal. The input source code is the entire program, dependent on commercial software. This code is transferred to a server and prepared for analysis as initial data. The output is a notification to the server that input is complete.

[0255] Step 2:

[0256] The server analyzes the received source code. This process uses static analysis tools to identify commercial program elements within the code. The input is the source code received in step 1, and the output is a list of identified commercial software components. Specifically, it detects dependent libraries and APIs.

[0257] Step 3:

[0258] The server uses a generative AI model to select open-source candidates to correspond to commercial program elements. The AI ​​model makes the optimal selection considering performance, compatibility, and licensing conditions. The input is a list of commercial software components obtained in step 2, and the output is a list of alternative open-access programs. Specifically, the AI ​​is given a prompt such as, "Suggest a means to replace a commercial database library with an open-source library."

[0259] Step 4:

[0260] The server automatically modifies the code using the proposed open-access program. The input is the open-source software selected in step 3. It replaces calls to commercial components in the code and automatically adjusts configuration files and APIs accordingly. The output is the modified source code.

[0261] Step 5:

[0262] The server performs tests on the modified source code to verify its functionality. The input is the source code modified in step 4, and the server uses unit and integration tests to verify the program's accuracy. The output is the test results. Specifically, the existing test suite is run to confirm that the output is as expected.

[0263] Step 6:

[0264] After the test is successfully completed, the terminal reports the migration results to the user. The input is the test results obtained in step 5, and the terminal outputs the results as an easy-to-understand report. Specifically, it notifies the user of the success of the migration process and provides the necessary detailed information.

[0265] (Application Example 1)

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

[0267] In corporate data centers and similar environments, efficiently and remotely monitoring the progress of migrations from commercial to open-source programs is difficult. Furthermore, the migration process requires specialized knowledge, and there is a need for methods to facilitate this process.

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

[0269] In this invention, the server includes a device for collecting source code, a device for analyzing the source code and identifying commercial program components, a device for recommending open-source programs to replace the commercial program components, a device for automatically converting the source code with the recommended open-source programs, a device for verifying that the converted source code functions correctly, and means for remotely monitoring software progress within the data center. This enables even users with limited technical knowledge to smoothly transition to open-source programs and remotely monitor their progress.

[0270] "Source code" is a set of instructions written in a human-readable format to define how a computer program works.

[0271] A "device" is a physical or virtual mechanism designed to perform a specific function or task.

[0272] "Commercial program components" refer to parts of software functionality that are provided commercially.

[0273] An "open-source program" is software whose source code is publicly available, allowing anyone to freely use, modify, and distribute it.

[0274] "Recommendation" is the act of presenting the option that is considered most appropriate for a particular purpose.

[0275] "Automatically converting" refers to changing a program or process into another form or function without human intervention.

[0276] "To function correctly" means to operate as designed and produce the expected results.

[0277] A "data center" is a dedicated facility established for the purpose of storing, managing, and distributing data.

[0278] "Remote monitoring" refers to the act of checking operations and situations through information technology, even without being directly present at the location.

[0279] A description of the embodiment for carrying out the invention will be provided.

[0280] This system is a solution for efficiently migrating from commercial programs to open-source programs in enterprise data centers. It is primarily operated via servers and user terminals. The system automates the process of identifying program components and replacing them with open-source programs.

[0281] The server receives source code from the user's terminal and begins analysis to identify components of the commercial program. This analysis includes interpreting dependencies. Once the analysis is complete, the server uses a generative AI model to recommend the most suitable open-source program. This recommendation takes into account performance, compatibility, and usage conditions. The server then automatically converts the source code using the open-source program selected from these options.

[0282] After conversion, the server performs tests to verify that the new program functions correctly. These tests are also automated, and if correct operation is confirmed, the user's terminal is notified of the progress and results.

[0283] This system also enables users to remotely monitor the software progress within the data center. Users can check the operation of the system from their smart devices through cloud services.

[0284] As a specific example, when replacing new commercial database management software with open-source software, using this system can automatically modify all related queries and settings of the server and optimize the program. This allows administrators with little technical knowledge to work smoothly.

[0285] As an example of a prompt sentence, there is "Please explain the procedure for converting the commercial database software in the data center of Company A to open source. Pay particular attention to the method of remotely checking the progress of the replacement work."

[0286] The flow of a specific process in Application Example 1 will be described using FIG. 12.

[0287] Step 1:

[0288] The server obtains the source code from the user terminal. This source code serves as the input, based on which the server prepares to analyze the entire program. The purpose of the analysis is to identify the commercial program components contained within the source code.

[0289] Step 2:

[0290] The server analyzes the obtained source code. In the analysis process, it identifies the commercial program components and interprets the dependencies. Based on the source code received as input, it constructs an abstract syntax tree and lists up the commercial components. This information is used for selecting alternative programs in the next step.

[0291] Step 3:

[0292] The server uses a generative AI model to recommend open-source programs as alternatives to identified commercial program components. Using the analysis results as input, it generates candidates while considering performance, compatibility, and usage conditions. The output is a list of recommended open-source programs.

[0293] Step 4:

[0294] The server automatically converts source code using recommended open-source programs. The input consists of a list and the original source code, and the server replaces the code based on these. Here, it modifies data structures and API calls as needed to generate new code.

[0295] Step 5:

[0296] The server performs tests on the converted source code. Using the converted code as input, it runs unit and integration tests to verify that the system functions correctly. The output is the test result, which is then reported to the user.

[0297] Step 6:

[0298] Users remotely monitor the progress using their devices. The devices receive notifications and logs from the server, which then display the conversion progress and test results. This allows users to verify that the migration has been successfully completed.

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

[0300] This invention relates to an AI agent system that recognizes user emotions and optimizes tasks during the migration process from commercial software to open-source software. The server first receives source code from the user and analyzes it to identify commercial software components. Then, it uses generative AI to suggest suitable open-source software candidates, while simultaneously acquiring the user's emotions in real time through an emotion engine and dynamically adjusting the suggestions to align with the user's expectations.

[0301] The sentiment engine analyzes how users react to suggestions. For example, if the user is satisfied with the suggested open-source software, the process proceeds as is; if dissatisfied, the suggestion is refined to explore other options. Furthermore, the server automatically converts the code to match the suggestion and then tests the converted code.

[0302] Based on the test results, the emotion engine measures user reactions and analyzes the feedback to improve user satisfaction with the results. The server uses this feedback to continuously improve and incorporate it into future suggestions and transformation processes. For example, when the server replaces a recognized commercial data analysis library in a project the user is involved in with a similar open-source library, it adjusts the presentation of different library candidates based on the user's favorable reactions, efficiently supporting the transition away from commercial licenses.

[0303] In this way, we support the transition to open-source software that reflects user sentiment, and realize a system that improves both efficiency and usability simultaneously.

[0304] The following describes the processing flow.

[0305] Step 1:

[0306] The user accesses the system and uploads the source code to be converted to the server. The server receives this and prepares for analysis.

[0307] Step 2:

[0308] The server analyzes the source code in detail using an analysis tool to identify commercial software components. The analysis results include software dependencies and a list of external libraries used.

[0309] Step 3:

[0310] The server uses generative AI to propose alternative open-source software based on the analysis results. Here, the sentiment engine is activated to analyze whether the proposed content is satisfactory while monitoring the user's reaction.

[0311] Step 4:

[0312] If it is determined that the user's sentiment is positive towards the proposal, the server automatically converts the source code with the proposed OSS. If it is negative, the generative AI re-proposes other possible options and re-evaluates the user's satisfaction.

[0313] Step 5:

[0314] The server executes tests on the converted code. The tests include unit tests and integration tests to confirm that the code operates as per the specifications.

[0315] Step 6:

[0316] After the test results are obtained, the terminal presents the results to the user as feedback. At this time, the sentiment engine analyzes the user's reaction again, evaluates the final satisfaction, and collects data on points to be improved next time.

[0317] Step 7:

[0318] The server uses the collected data to make adjustments to improve the efficiency of subsequent processes. This enables continuous process improvement.

[0319] (Example 2)

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

[0321] The migration process from commercial programs to open-source programs is complex and time-consuming, and can lead to decreased usability and inefficiency because it often proceeds without adequately considering user expectations and feelings. Furthermore, while moving away from commercial licenses is important, calculating the associated risks and costs is difficult. Therefore, a system is needed that enables efficient software migration while reflecting user sentiment.

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

[0323] In this invention, the server includes means for acquiring source code, means for analyzing the source code to identify commercial program components, means for proposing public source programs to replace the commercial program components, means for acquiring the user's emotional state in real time and dynamically adjusting the proposal, means for automatically converting the source code with the proposed public source programs, means for testing that the converted source code operates correctly, and means for analyzing user feedback based on the test results and improving the process. This enables an efficient and effective transition from commercial software to public source software while taking user emotions into consideration.

[0324] "Source code" is a collection of text-based instructions used to describe software or programs, which are then converted into a format that a computer can execute.

[0325] "Commercial program components" refer to parts or all of software that are provided under a commercial license and often incur a fee for use.

[0326] "Open source program" refers to any part or all of software provided under an open-source license that is free to use, modify, and redistribute.

[0327] "User emotional state" refers to the psychological and emotional responses a user exhibits to using a system or proposed software, and is typically measured in real time.

[0328] "Real-time acquisition" means that data and information are collected instantly at the moment processing takes place, and that they are obtained without delay.

[0329] "Dynamic adjustment" refers to a system automatically changing its content and settings in response to changing circumstances to maintain an optimal state.

[0330] "Automatic conversion" refers to a system or program mechanically processing data without human intervention, changing it into a different format or content.

[0331] "Testing for proper operation" refers to a series of verification processes to ensure that software operates as required and delivers the intended results.

[0332] "Analyzing feedback" refers to examining evaluations and opinions provided by users and using them to identify areas for system improvement.

[0333] In this invention, the server obtains source code provided by the user and performs analysis thereon. Here, specific code analysis tools are used to identify commercial program components. For example, general program analysis software may be used to extract source code dependencies.

[0334] After the analysis is complete, the server uses a generative AI model to suggest candidate open-source programs to replace the commercial program. This generative AI model is given instructions such as "Please suggest open-source alternatives to the commercial software currently in use."

[0335] The user's device displays a list of publicly available source programs suggested by the server, and the user makes a selection based on this list. The server can then acquire the user's responses and selections in real time using emotion recognition technology, and dynamically adjust its suggestions. Specifically, to improve user satisfaction, it uses facial recognition cameras and text analysis modules to evaluate the user's emotional state.

[0336] After the user selects candidates for publicly available source programs, the server automatically converts the source code based on these selections. The converted code is then tested in a test environment for functionality verification. A general-purpose testing framework is typically used during this process. This process ensures that all functions work correctly and that the functionality is as expected.

[0337] Finally, the server receives the test results as feedback from the user and analyzes it. Based on the data obtained, it improves future suggestions and the source code conversion process. This feedback process allows for a systematic improvement in user satisfaction.

[0338] This system is designed to facilitate a smooth transition from commercial to open-source programs while reflecting user sentiment, and to improve efficiency and usability.

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

[0340] Step 1:

[0341] The server obtains source code as input from the user. Specifically, the source code is provided via a URL specified by the user or through a file upload. The server records this obtained source code and prepares it for the next analysis step.

[0342] Step 2:

[0343] The server analyzes the acquired source code and identifies commercial program components. It receives the entire source code as input and uses program analysis tools to detect commercial components within the program. This process generates detailed data on dependencies and library usage. The identified commercial components are then utilized in the next proposed step.

[0344] Step 3:

[0345] The server uses a generative AI model to suggest open-source alternatives to commercial programs. Using information on the commercial program components identified as input, and based on the prompt "Suggest open-source alternatives to the commercial software currently in use," the generative AI model outputs candidate open-source programs. The suggested options are then presented to the user.

[0346] Step 4:

[0347] The terminal displays a list of publicly available source programs received from the server to the user. The user reviews the list and makes a selection. Based on the user's selection input, the server records the user's choice.

[0348] Step 5:

[0349] Based on user selection, the server automatically converts the source code. Using the user-selected public source program as input, it replaces commercial components using a code conversion tool. This process generates new source code as the conversion result.

[0350] Step 6:

[0351] The server tests the converted source code in a test environment. It receives the converted source code as input and uses a test framework to verify its operation. Output results are obtained that verify whether the functionality is executed correctly.

[0352] Step 7:

[0353] The server collects and analyzes user feedback based on test results. It takes test results and user ratings as input and uses an emotion engine to assess satisfaction. This analysis generates feedback information useful for future suggestions and process improvements.

[0354] (Application Example 2)

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

[0356] In the migration process from commercial software to open-source software, there is a need to present appropriate alternatives that take user sentiment into consideration, and to carry out the migration work efficiently and satisfactorily. Furthermore, challenges include proposing software that meets user expectations, automating code conversion, and ensuring its accuracy.

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

[0358] In this invention, the server includes means for acquiring source code, means for analyzing the source code to identify commercial software components, means for proposing open-source software to replace the commercial software components, means for acquiring the user's emotional state using emotion recognition means and dynamically adjusting the content of the proposal, means for automatically converting the source code with the proposed open-source software, and means for testing that the converted source code operates correctly. This enables an effective transition to open-source software that takes the user's emotions into consideration.

[0359] "Means of obtaining source code" refers to methods and techniques for obtaining a set of instructions used in the design and development of a program.

[0360] "Means for analyzing source code to identify commercial software components" refers to methods and techniques for thoroughly examining source code, extracting elements of commercially used software from it, and identifying them.

[0361] "Methods for proposing open-source software" refer to methods and technologies for presenting freely available software as an alternative to commercial software.

[0362] "Emotion recognition means" refers to methods and technologies for identifying and understanding a user's emotional state.

[0363] "Means of dynamic adjustment" refer to methods and techniques for automatically changing system or process settings in response to changes in circumstances or conditions.

[0364] "Means of automatic conversion" refers to methods and technologies for converting source code to different formats or specifications without human intervention.

[0365] "Testing methods" refer to the methods and techniques used to perform tests to ensure that source code or programs function correctly.

[0366] To implement this invention, a server-centric system is required. The server first acquires source code provided by the user and identifies commercial software components using the source code analysis platform "LibCST". Based on these identified components, a generative AI model is used to propose alternative open-source software. At this time, emotion recognition technology is used to acquire the user's emotional state in real time, and the open-source options presented by the generative AI are dynamically adjusted based on this data.

[0367] For sentiment recognition, the natural language processing library "TextBlob" is used. This allows sentiment values ​​to be extracted from user feedback and comments. If the proposed open-source software meets user expectations, the server automatically converts the source code. After this automatic conversion process, the server performs testing to verify that the converted code works correctly. The environment used for this testing includes Python and various testing frameworks.

[0368] As a concrete example, consider a system where, when a home robot open-sources software for a music playback service, it detects commercial libraries, suggests alternative open-source libraries through generative AI, and adjusts the candidates based on user feedback. In this process, the generative AI model can be instructed with a prompt such as: "Suggest open-source alternatives for voice recognition software used in home robots."

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

[0370] Step 1:

[0371] The server receives source code from the user. The input is the source code provided by the user, and the output is the source code data to be analyzed. In this process, the system confirms receipt of the source code and prepares to proceed to the next analysis stage.

[0372] Step 2:

[0373] The server uses the "LibCST" library to analyze the received source code and identify commercial software components. The input is the received source code, and the output is a list of commercial software components. Specifically, it generates an AST (Abstract Syntax Tree) to detect where commercial libraries and APIs are used.

[0374] Step 3:

[0375] The server uses a generative AI model to suggest open-source software alternatives to identified commercial software components. It takes a list of commercial software components as input and generates a list of open-source software candidates as output. Prompts are used to instruct the generative AI model and generate the optimal choice.

[0376] Step 4:

[0377] The server acquires the user's emotional state using emotion recognition mechanisms. Input is user feedback and comments, and output is an emotion value. Specifically, the TextBlob library is used to calculate the emotion value from the feedback text, and this information is used to adjust the suggested alternatives.

[0378] Step 5:

[0379] The server automatically converts source code based on the proposed open-source software. The input is information about the selected open-source software and the original source code, and the output is the converted source code. The conversion includes replacing commercial libraries and modifying corresponding code structures.

[0380] Step 6:

[0381] The server uses testing methods to verify that the converted source code works correctly. The input is the converted source code, and the output is the test results. The server ensures the accuracy of the code by checking for bugs and errors in the program and debugging as needed.

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

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

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

[0385] [Third Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0398] This invention is an AI agent system that efficiently replaces a company's existing software with open-source software. First, when a user uses this system, the existing source code that depends on commercial software is input into the system. Based on this, the server automatically analyzes the entire program and identifies the commercial software components.

[0399] After analysis, the server uses a generative AI to search for open-source software that can replace the identified commercial software. The selection process considers performance, compatibility, and licensing conditions to propose the most suitable alternative. Once this proposal is finalized, the server automatically converts the relevant code into open-source software.

[0400] After the conversion process is complete, the server runs unit and integration tests on the converted source code to ensure it functions the same way as the original program. Once the functionality check is complete, the terminal reports the completion of the migration and its results to the user. For example, when the server converts a commercial database library to an open-source PostgreSQL library, it efficiently optimizes the program by automatically making necessary query modifications and configuration changes.

[0401] This system allows users to quickly and reliably migrate to open-source software (OSS) without requiring particularly deep technical knowledge.

[0402] The following describes the processing flow.

[0403] Step 1:

[0404] The server retrieves the source code specified by the user from the repository. This includes cloning and downloading over the network.

[0405] Step 2:

[0406] The server uses code analysis tools to thoroughly analyze the retrieved source code. During this process, it checks for the presence of commercial software components and maps dependencies and structure.

[0407] Step 3:

[0408] Based on the analysis results, the server uses a generative AI to search for suitable open-source software candidates. Selection criteria include performance, compatibility, and licensing conditions.

[0409] Step 4:

[0410] The server selects the most suitable open-source software from the proposed candidates and performs code conversion to replace commercial software components with it. Function calls and configuration file modifications are also made.

[0411] Step 5:

[0412] The server runs unit and integration tests to verify that the converted source code functions correctly. This ensures that each function is implemented accurately.

[0413] Step 6:

[0414] The terminal presents the user with a report detailing the conversion results and test success. The report includes information on which commercial software was replaced and the expected cost savings and performance improvements as a result.

[0415] (Example 1)

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

[0417] Migrating programs that rely on existing commercial software to open-source software is a time-consuming and specialized task for many developers. This process requires selecting the right open-source software, replacing the commercial software, and verifying the functionality of the replacement code, often resulting in errors and inefficiencies. Furthermore, selecting open-source software requires considering performance, compatibility, and licensing terms, necessitating an efficient and automated migration method that takes these factors into account.

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

[0419] In this invention, the server includes means for collecting code, means for analyzing the code and identifying commercial program elements, and means for recommending open access programs while considering selection criteria using a generative artificial intelligence model. This enables even users without specialized knowledge to quickly and accurately migrate from commercial software to open-source software.

[0420] "Means of collecting code" refers to devices or methods for collecting program source code and incorporating it into a management system.

[0421] "Means of analyzing code and identifying commercial program elements" refers to methods of examining collected code and identifying parts that depend on specific commercial software.

[0422] "A method for recommending open access programs while considering selection criteria using a generative artificial intelligence model" refers to a method that uses artificial intelligence technology to evaluate performance, compatibility, and licensing conditions while presenting the most suitable open-source programs.

[0423] "Commercial program elements" are proprietary software components used through purchase or licensing agreements.

[0424] An "open access program" is software whose source code is publicly available and which is freely permitted to be used, modified, and distributed.

[0425] "Means of modification" refers to methods for automatically rewriting the original code to conform to a new library or program.

[0426] "Verification methods" refer to testing methods used to confirm that the modified code correctly performs the intended function.

[0427] This invention is a system for efficiently migrating existing source code that relies on commercial software to open-source software. The system operates through the interaction of a server, terminal, and user, and achieves the following functions.

[0428] First, the user inputs source code dependent on commercial software into the server via a terminal. The terminal can send the source code in the appropriate format, and this data becomes the system's input information.

[0429] Next, the server analyzes the received source code. Static analysis tools are used for this analysis to identify commercial program elements. In this process, the server utilizes a generative AI model to set selection criteria for the optimal open-source software based on the analyzed information. These criteria include performance, compatibility, and licensing terms.

[0430] After analysis, the server uses a generative artificial intelligence model to recommend open-access programs. Specifically, it provides prompts to the generative AI model to suggest appropriate alternative software. An example of a prompt might be, "Suggest steps to convert existing database API calls to open-source versions."

[0431] After a recommended open-source program is suggested, the server performs an automated code modification. Here, the relevant code is rewritten to the standard open-source version, and related API calls and settings are automatically adjusted.

[0432] Finally, the server performs operational verification on the modified code. Unit tests and integration tests are used to confirm that the code functions correctly. After the tests are complete, the terminal notifies the user of the results and reports that the migration process has been successfully completed.

[0433] This system enables users to migrate from commercial code to open source with high accuracy, reducing overall project costs and increasing flexibility without requiring technical knowledge.

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

[0435] Step 1:

[0436] The user inputs source code via a terminal. The input source code is the entire program, dependent on commercial software. This code is transferred to a server and prepared for analysis as initial data. The output is a notification to the server that input is complete.

[0437] Step 2:

[0438] The server analyzes the received source code. This process uses static analysis tools to identify commercial program elements within the code. The input is the source code received in step 1, and the output is a list of identified commercial software components. Specifically, it detects dependent libraries and APIs.

[0439] Step 3:

[0440] The server uses a generative AI model to select open-source candidates to correspond to commercial program elements. The AI ​​model makes the optimal selection considering performance, compatibility, and licensing conditions. The input is a list of commercial software components obtained in step 2, and the output is a list of alternative open-access programs. Specifically, the AI ​​is given a prompt such as, "Suggest a means to replace a commercial database library with an open-source library."

[0441] Step 4:

[0442] The server automatically modifies the code using the proposed open-access program. The input is the open-source software selected in step 3. It replaces calls to commercial components in the code and automatically adjusts configuration files and APIs accordingly. The output is the modified source code.

[0443] Step 5:

[0444] The server performs tests on the modified source code to verify its functionality. The input is the source code modified in step 4, and the server uses unit and integration tests to verify the program's accuracy. The output is the test results. Specifically, the existing test suite is run to confirm that the output is as expected.

[0445] Step 6:

[0446] After the test is successfully completed, the terminal reports the migration results to the user. The input is the test results obtained in step 5, and the terminal outputs the results as an easy-to-understand report. Specifically, it notifies the user of the success of the migration process and provides the necessary detailed information.

[0447] (Application Example 1)

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

[0449] In corporate data centers and similar environments, efficiently and remotely monitoring the progress of migrations from commercial to open-source programs is difficult. Furthermore, the migration process requires specialized knowledge, and there is a need for methods to facilitate this process.

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

[0451] In this invention, the server includes a device for collecting source code, a device for analyzing the source code and identifying commercial program components, a device for recommending open-source programs to replace the commercial program components, a device for automatically converting the source code with the recommended open-source programs, a device for verifying that the converted source code functions correctly, and means for remotely monitoring software progress within the data center. This enables even users with limited technical knowledge to smoothly transition to open-source programs and remotely monitor their progress.

[0452] "Source code" is a set of instructions written in a human-readable format to define how a computer program works.

[0453] A "device" is a physical or virtual mechanism designed to perform a specific function or task.

[0454] "Commercial program components" refer to parts of software functionality that are provided commercially.

[0455] An "open-source program" is software whose source code is publicly available, allowing anyone to freely use, modify, and distribute it.

[0456] "Recommendation" is the act of presenting the option that is considered most appropriate for a particular purpose.

[0457] "Automatically converting" refers to changing a program or process into another form or function without human intervention.

[0458] "To function correctly" means to operate as designed and produce the expected results.

[0459] A "data center" is a dedicated facility established for the purpose of storing, managing, and distributing data.

[0460] "Remote monitoring" refers to the act of checking operations and situations through information technology, even without being directly present at the location.

[0461] A description of the embodiment for carrying out the invention will be provided.

[0462] This system is a solution for efficiently migrating from commercial programs to open-source programs in enterprise data centers. It is primarily operated via servers and user terminals. The system automates the process of identifying program components and replacing them with open-source programs.

[0463] The server receives source code from the user's terminal and begins analysis to identify components of the commercial program. This analysis includes interpreting dependencies. Once the analysis is complete, the server uses a generative AI model to recommend the most suitable open-source program. This recommendation takes into account performance, compatibility, and usage conditions. The server then automatically converts the source code using the open-source program selected from these options.

[0464] After conversion, the server performs tests to verify that the new program functions correctly. These tests are also automated, and if correct operation is confirmed, the user's terminal is notified of the progress and results.

[0465] This system also allows users to remotely monitor software progress within the data center. Users can check the system's operation from their smart devices via cloud services.

[0466] For example, when replacing new commercial database management software with open-source software, this system can be used to automatically modify all related queries and settings on the server and optimize the program. This allows even administrators with limited technical knowledge to work smoothly.

[0467] An example of a prompt message is: "Describe the steps to convert commercial database software in Company A's data center to open source. Focus particularly on how to remotely monitor the progress of the replacement work."

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

[0469] Step 1:

[0470] The server retrieves the source code from the user's terminal. This source code serves as input, and the server prepares to analyze the entire program based on it. The purpose of the analysis is to identify the commercial program components contained within the source code.

[0471] Step 2:

[0472] The server analyzes the acquired source code. The analysis process identifies commercial program components and interprets their dependencies. Based on the source code received as input, it constructs an abstract syntax tree and lists the commercial components. This information is used in the next step to select an alternative program.

[0473] Step 3:

[0474] The server uses a generative AI model to recommend open-source programs as alternatives to identified commercial program components. Using the analysis results as input, it generates candidates considering performance, compatibility, and usage conditions. The output is a list of recommended open-source programs.

[0475] Step 4:

[0476] The server automatically converts source code using recommended open-source programs. The input consists of a list and the original source code, and the server replaces the code based on these. Here, it modifies data structures and API calls as needed to generate new code.

[0477] Step 5:

[0478] The server performs tests on the converted source code. Using the converted code as input, it runs unit and integration tests to verify that the system functions correctly. The output is the test result, which is then reported to the user.

[0479] Step 6:

[0480] Users remotely monitor the progress using their devices. The devices receive notifications and logs from the server, which then display the conversion progress and test results. This allows users to verify that the migration has been successfully completed.

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

[0482] This invention relates to an AI agent system that recognizes user emotions and optimizes tasks during the migration process from commercial software to open-source software. The server first receives source code from the user and analyzes it to identify commercial software components. Then, it uses generative AI to suggest suitable open-source software candidates, while simultaneously acquiring the user's emotions in real time through an emotion engine and dynamically adjusting the suggestions to align with the user's expectations.

[0483] The sentiment engine analyzes how users react to suggestions. For example, if the user is satisfied with the suggested open-source software, the process proceeds as is; if dissatisfied, the suggestion is refined to explore other options. Furthermore, the server automatically converts the code to match the suggestion and then tests the converted code.

[0484] Based on the test results, the emotion engine measures user reactions and analyzes the feedback to improve user satisfaction with the results. The server uses this feedback to continuously improve and incorporate it into future suggestions and transformation processes. For example, when the server replaces a recognized commercial data analysis library in a project the user is involved in with a similar open-source library, it adjusts the presentation of different library candidates based on the user's favorable reactions, efficiently supporting the transition away from commercial licenses.

[0485] In this way, we support the transition to open-source software that reflects user sentiment, and realize a system that improves both efficiency and usability simultaneously.

[0486] The following describes the processing flow.

[0487] Step 1:

[0488] The user accesses the system and uploads the source code to be converted to the server. The server receives it and prepares it for analysis.

[0489] Step 2:

[0490] The server uses analysis tools to perform a detailed analysis of the source code and identify commercial software components. The analysis results include a list of software dependencies and external libraries used.

[0491] Step 3:

[0492] The server uses a generative AI to suggest alternative open-source software based on the analysis results. At this point, an emotion engine is activated to monitor the user's reaction and analyze whether the suggestions are satisfactory.

[0493] Step 4:

[0494] If the user's sentiment is determined to be positive towards the suggestion, the server automatically converts the source code with the suggested open-source software (OSS). If it is negative, the generating AI re-suggests other possible options and re-evaluates the user's satisfaction.

[0495] Step 5:

[0496] The server runs tests on the converted code. These tests include unit tests and integration tests to ensure the code works according to specifications.

[0497] Step 6:

[0498] After the test results are obtained, the device presents the results to the user as feedback. At this time, the emotion engine re-analyzes the user's response, evaluates the final satisfaction level, and collects data on areas for improvement next time.

[0499] Step 7:

[0500] The server uses the collected data to make adjustments to improve the efficiency of subsequent processes. This enables continuous process improvement.

[0501] (Example 2)

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

[0503] The migration process from commercial programs to open-source programs is complex and time-consuming, and can lead to decreased usability and inefficiency because it often proceeds without adequately considering user expectations and feelings. Furthermore, while moving away from commercial licenses is important, calculating the associated risks and costs is difficult. Therefore, a system is needed that enables efficient software migration while reflecting user sentiment.

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

[0505] In this invention, the server includes means for acquiring source code, means for analyzing the source code to identify commercial program components, means for proposing public source programs to replace the commercial program components, means for acquiring the user's emotional state in real time and dynamically adjusting the proposal, means for automatically converting the source code with the proposed public source programs, means for testing that the converted source code operates correctly, and means for analyzing user feedback based on the test results and improving the process. This enables an efficient and effective transition from commercial software to public source software while taking user emotions into consideration.

[0506] "Source code" is a collection of text-based instructions used to describe software or programs, which are then converted into a format that a computer can execute.

[0507] "Commercial program components" refer to parts or all of software that are provided under a commercial license and often incur a fee for use.

[0508] "Open source program" refers to any part or all of software provided under an open-source license that is free to use, modify, and redistribute.

[0509] "User emotional state" refers to the psychological and emotional responses a user exhibits to using a system or proposed software, and is typically measured in real time.

[0510] "Real-time acquisition" means that data and information are collected instantly at the moment processing takes place, and that they are obtained without delay.

[0511] "Dynamic adjustment" refers to a system automatically changing its content and settings in response to changing circumstances to maintain an optimal state.

[0512] "Automatic conversion" refers to a system or program mechanically processing data without human intervention, changing it into a different format or content.

[0513] "Testing for proper operation" refers to a series of verification processes to ensure that software operates as required and delivers the intended results.

[0514] "Analyzing feedback" refers to examining evaluations and opinions provided by users and using them to identify areas for system improvement.

[0515] In this invention, the server obtains source code provided by the user and performs analysis thereon. Here, specific code analysis tools are used to identify commercial program components. For example, general program analysis software may be used to extract source code dependencies.

[0516] After the analysis is complete, the server uses a generative AI model to suggest candidate open-source programs to replace the commercial program. This generative AI model is given instructions such as "Please suggest open-source alternatives to the commercial software currently in use."

[0517] The user's device displays a list of publicly available source programs suggested by the server, and the user makes a selection based on this list. The server can then acquire the user's responses and selections in real time using emotion recognition technology, and dynamically adjust its suggestions. Specifically, to improve user satisfaction, it uses facial recognition cameras and text analysis modules to evaluate the user's emotional state.

[0518] After the user selects candidates for publicly available source programs, the server automatically converts the source code based on these selections. The converted code is then tested in a test environment for functionality verification. A general-purpose testing framework is typically used during this process. This process ensures that all functions work correctly and that the functionality is as expected.

[0519] Finally, the server receives the test results as feedback from the user and analyzes it. Based on the data obtained, it improves future suggestions and the source code conversion process. This feedback process allows for a systematic improvement in user satisfaction.

[0520] This system is designed to facilitate a smooth transition from commercial to open-source programs while reflecting user sentiment, and to improve efficiency and usability.

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

[0522] Step 1:

[0523] The server obtains source code as input from the user. Specifically, the source code is provided via a URL specified by the user or through a file upload. The server records this obtained source code and prepares it for the next analysis step.

[0524] Step 2:

[0525] The server analyzes the acquired source code and identifies commercial program components. It receives the entire source code as input and uses program analysis tools to detect commercial components within the program. This process generates detailed data on dependencies and library usage. The identified commercial components are then utilized in the next proposed step.

[0526] Step 3:

[0527] The server uses a generative AI model to suggest open-source alternatives to commercial programs. Using information on the commercial program components identified as input, and based on the prompt "Suggest open-source alternatives to the commercial software currently in use," the generative AI model outputs candidate open-source programs. The suggested options are then presented to the user.

[0528] Step 4:

[0529] The terminal displays a list of publicly available source programs received from the server to the user. The user reviews the list and makes a selection. Based on the user's selection input, the server records the user's choice.

[0530] Step 5:

[0531] Based on user selection, the server automatically converts the source code. Using the user-selected public source program as input, it replaces commercial components using a code conversion tool. This process generates new source code as the conversion result.

[0532] Step 6:

[0533] The server tests the converted source code in a test environment. It receives the converted source code as input and uses a test framework to verify its operation. Output results are obtained that verify whether the functionality is executed correctly.

[0534] Step 7:

[0535] The server collects and analyzes user feedback based on test results. It takes test results and user ratings as input and uses an emotion engine to assess satisfaction. This analysis generates feedback information useful for future suggestions and process improvements.

[0536] (Application Example 2)

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

[0538] In the migration process from commercial software to open-source software, there is a need to present appropriate alternatives that take user sentiment into consideration, and to carry out the migration work efficiently and satisfactorily. Furthermore, challenges include proposing software that meets user expectations, automating code conversion, and ensuring its accuracy.

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

[0540] In this invention, the server includes means for acquiring source code, means for analyzing the source code to identify commercial software components, means for proposing open-source software to replace the commercial software components, means for acquiring the user's emotional state using emotion recognition means and dynamically adjusting the content of the proposal, means for automatically converting the source code with the proposed open-source software, and means for testing that the converted source code operates correctly. This enables an effective transition to open-source software that takes the user's emotions into consideration.

[0541] "Means of obtaining source code" refers to methods and techniques for obtaining a set of instructions used in the design and development of a program.

[0542] "Means for analyzing source code to identify commercial software components" refers to methods and techniques for thoroughly examining source code, extracting from it elements of commercially used software, and identifying them.

[0543] "Methods for proposing open-source software" refer to methods and technologies for presenting freely available software as an alternative to commercial software.

[0544] "Emotion recognition means" refers to methods and technologies for identifying and understanding a user's emotional state.

[0545] "Means of dynamic adjustment" refer to methods and techniques for automatically changing system or process settings in response to changes in circumstances or conditions.

[0546] "Means of automatic conversion" refers to methods and technologies for converting source code to different formats or specifications without human intervention.

[0547] "Testing methods" refer to the methods and techniques used to perform tests to ensure that source code or programs function correctly.

[0548] To implement this invention, a server-centric system is required. The server first acquires source code provided by the user and identifies commercial software components using the source code analysis platform "LibCST". Based on these identified components, a generative AI model is used to propose alternative open-source software. At this time, emotion recognition technology is used to acquire the user's emotional state in real time, and the open-source options presented by the generative AI are dynamically adjusted based on this data.

[0549] For sentiment recognition, the natural language processing library "TextBlob" is used. This allows sentiment values ​​to be extracted from user feedback and comments. If the proposed open-source software meets user expectations, the server automatically converts the source code. After this automatic conversion process, the server performs testing to verify that the converted code works correctly. The environment used for this testing includes Python and various testing frameworks.

[0550] As a concrete example, consider a system where, when a home robot open-sources software for a music playback service, it detects commercial libraries, suggests alternative open-source libraries through generative AI, and adjusts the candidates based on user feedback. In this process, the generative AI model can be instructed with a prompt such as: "Suggest open-source alternatives for voice recognition software used in home robots."

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

[0552] Step 1:

[0553] The server receives source code from the user. The input is the source code provided by the user, and the output is the source code data to be analyzed. In this process, the system confirms receipt of the source code and prepares to proceed to the next analysis stage.

[0554] Step 2:

[0555] The server uses the "LibCST" library to analyze the received source code and identify commercial software components. The input is the received source code, and the output is a list of commercial software components. Specifically, it generates an AST (Abstract Syntax Tree) to detect where commercial libraries and APIs are used.

[0556] Step 3:

[0557] The server uses a generative AI model to suggest open-source software alternatives to identified commercial software components. It takes a list of commercial software components as input and generates a list of open-source software candidates as output. Prompts are used to instruct the generative AI model and generate the optimal choice.

[0558] Step 4:

[0559] The server acquires the user's emotional state using emotion recognition mechanisms. Input is user feedback and comments, and output is an emotion value. Specifically, the TextBlob library is used to calculate the emotion value from the feedback text, and this information is used to adjust the suggested alternatives.

[0560] Step 5:

[0561] The server automatically converts source code based on the proposed open-source software. The input is information about the selected open-source software and the original source code, and the output is the converted source code. The conversion includes replacing commercial libraries and modifying corresponding code structures.

[0562] Step 6:

[0563] The server uses testing methods to verify that the converted source code works correctly. The input is the converted source code, and the output is the test results. The server ensures the accuracy of the code by checking for bugs and errors in the program and debugging as needed.

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

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

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

[0567] [Fourth Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[0581] This invention is an AI agent system that efficiently replaces a company's existing software with open-source software. First, when a user uses this system, the existing source code that depends on commercial software is input into the system. Based on this, the server automatically analyzes the entire program and identifies the commercial software components.

[0582] After analysis, the server uses a generative AI to search for open-source software that can replace the identified commercial software. The selection process considers performance, compatibility, and licensing conditions to propose the most suitable alternative. Once this proposal is finalized, the server automatically converts the relevant code into open-source software.

[0583] After the conversion process is complete, the server runs unit and integration tests on the converted source code to ensure it functions the same way as the original program. Once the functionality check is complete, the terminal reports the completion of the migration and its results to the user. For example, when the server converts a commercial database library to an open-source PostgreSQL library, it efficiently optimizes the program by automatically making necessary query modifications and configuration changes.

[0584] This system allows users to quickly and reliably migrate to open-source software (OSS) without requiring particularly deep technical knowledge.

[0585] The following describes the processing flow.

[0586] Step 1:

[0587] The server retrieves the source code specified by the user from the repository. This includes cloning and downloading over the network.

[0588] Step 2:

[0589] The server uses code analysis tools to thoroughly analyze the retrieved source code. During this process, it checks for the presence of commercial software components and maps dependencies and structure.

[0590] Step 3:

[0591] Based on the analysis results, the server uses a generative AI to search for suitable open-source software candidates. Selection criteria include performance, compatibility, and licensing conditions.

[0592] Step 4:

[0593] The server selects the most suitable open-source software from the proposed candidates and performs code conversion to replace commercial software components with it. Function calls and configuration file modifications are also made.

[0594] Step 5:

[0595] The server runs unit and integration tests to verify that the converted source code functions correctly. This ensures that each function is implemented accurately.

[0596] Step 6:

[0597] The terminal presents the user with a report detailing the conversion results and test success. The report includes information on which commercial software was replaced and the expected cost savings and performance improvements as a result.

[0598] (Example 1)

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

[0600] Migrating programs that rely on existing commercial software to open-source software is a time-consuming and specialized task for many developers. This process requires selecting the right open-source software, replacing the commercial software, and verifying the functionality of the replacement code, often resulting in errors and inefficiencies. Furthermore, selecting open-source software requires considering performance, compatibility, and licensing terms, necessitating an efficient and automated migration method that takes these factors into account.

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

[0602] In this invention, the server includes means for collecting code, means for analyzing the code and identifying commercial program elements, and means for recommending open access programs while considering selection criteria using a generative artificial intelligence model. This enables even users without specialized knowledge to quickly and accurately migrate from commercial software to open-source software.

[0603] "Means of collecting code" refers to devices or methods for collecting program source code and incorporating it into a management system.

[0604] "Means of analyzing code and identifying commercial program elements" refers to methods of examining collected code and identifying parts that depend on specific commercial software.

[0605] "A method for recommending open access programs while considering selection criteria using a generative artificial intelligence model" refers to a method that uses artificial intelligence technology to evaluate performance, compatibility, and licensing conditions while presenting the most suitable open-source programs.

[0606] "Commercial program elements" are proprietary software components used through purchase or licensing agreements.

[0607] An "open access program" is software whose source code is publicly available and which is freely permitted to be used, modified, and distributed.

[0608] "Means of modification" refers to methods for automatically rewriting the original code to conform to a new library or program.

[0609] "Verification methods" refer to testing methods used to confirm that the modified code correctly performs the intended function.

[0610] This invention is a system for efficiently migrating existing source code that relies on commercial software to open-source software. The system operates through the interaction of a server, terminal, and user, and achieves the following functions.

[0611] First, the user inputs source code dependent on commercial software into the server via a terminal. The terminal can send the source code in the appropriate format, and this data becomes the system's input information.

[0612] Next, the server analyzes the received source code. Static analysis tools are used for this analysis to identify commercial program elements. In this process, the server utilizes a generative AI model to set selection criteria for the optimal open-source software based on the analyzed information. These criteria include performance, compatibility, and licensing terms.

[0613] After analysis, the server uses a generative artificial intelligence model to recommend open-access programs. Specifically, it provides prompts to the generative AI model to suggest appropriate alternative software. An example of a prompt might be, "Suggest steps to convert existing database API calls to open-source versions."

[0614] After a recommended open-source program is suggested, the server performs an automated code modification. Here, the relevant code is rewritten to the standard open-source version, and related API calls and settings are automatically adjusted.

[0615] Finally, the server performs operational verification on the modified code. Unit tests and integration tests are used to confirm that the code functions correctly. After the tests are complete, the terminal notifies the user of the results and reports that the migration process has been successfully completed.

[0616] This system enables users to migrate from commercial code to open source with high accuracy, reducing overall project costs and increasing flexibility without requiring technical knowledge.

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

[0618] Step 1:

[0619] The user inputs source code via a terminal. The input source code is the entire program, dependent on commercial software. This code is transferred to a server and prepared for analysis as initial data. The output is a notification to the server that input is complete.

[0620] Step 2:

[0621] The server analyzes the received source code. This process uses static analysis tools to identify commercial program elements within the code. The input is the source code received in step 1, and the output is a list of identified commercial software components. Specifically, it detects dependent libraries and APIs.

[0622] Step 3:

[0623] The server uses a generative AI model to select open-source candidates to correspond to commercial program elements. The AI ​​model makes the optimal selection considering performance, compatibility, and licensing conditions. The input is a list of commercial software components obtained in step 2, and the output is a list of alternative open-access programs. Specifically, the AI ​​is given a prompt such as, "Suggest a means to replace a commercial database library with an open-source library."

[0624] Step 4:

[0625] The server automatically modifies the code using the proposed open-access program. The input is the open-source software selected in step 3. It replaces calls to commercial components in the code and automatically adjusts configuration files and APIs accordingly. The output is the modified source code.

[0626] Step 5:

[0627] The server performs tests on the modified source code to verify its functionality. The input is the source code modified in step 4, and the server uses unit and integration tests to verify the program's accuracy. The output is the test results. Specifically, the existing test suite is run to confirm that the output is as expected.

[0628] Step 6:

[0629] After the test is successfully completed, the terminal reports the migration results to the user. The input is the test results obtained in step 5, and the terminal outputs the results as an easy-to-understand report. Specifically, it notifies the user of the success of the migration process and provides the necessary detailed information.

[0630] (Application Example 1)

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

[0632] In corporate data centers and similar environments, efficiently and remotely monitoring the progress of migrations from commercial to open-source programs is difficult. Furthermore, the migration process requires specialized knowledge, and there is a need for methods to facilitate this process.

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

[0634] In this invention, the server includes a device for collecting source code, a device for analyzing the source code and identifying commercial program components, a device for recommending open-source programs to replace the commercial program components, a device for automatically converting the source code with the recommended open-source programs, a device for verifying that the converted source code functions correctly, and means for remotely monitoring software progress within the data center. This enables even users with limited technical knowledge to smoothly transition to open-source programs and remotely monitor their progress.

[0635] "Source code" is a set of instructions written in a human-readable format to define how a computer program works.

[0636] A "device" is a physical or virtual mechanism designed to perform a specific function or task.

[0637] "Commercial program components" refer to parts of software functionality that are provided commercially.

[0638] An "open-source program" is software whose source code is publicly available, allowing anyone to freely use, modify, and distribute it.

[0639] "Recommendation" is the act of presenting the option that is considered most appropriate for a particular purpose.

[0640] "Automatically converting" refers to changing a program or process into another form or function without human intervention.

[0641] "To function correctly" means to operate as designed and produce the expected results.

[0642] A "data center" is a dedicated facility established for the purpose of storing, managing, and distributing data.

[0643] "Remote monitoring" refers to the act of checking operations and situations through information technology, even without being directly present at the location.

[0644] A description of the embodiment for carrying out the invention will be provided.

[0645] This system is a solution for efficiently migrating from commercial programs to open-source programs in enterprise data centers. It is primarily operated via servers and user terminals. The system automates the process of identifying program components and replacing them with open-source programs.

[0646] The server receives source code from the user's terminal and begins analysis to identify components of the commercial program. This analysis includes interpreting dependencies. Once the analysis is complete, the server uses a generative AI model to recommend the most suitable open-source program. This recommendation takes into account performance, compatibility, and usage conditions. The server then automatically converts the source code using the open-source program selected from these options.

[0647] After conversion, the server performs tests to verify that the new program functions correctly. These tests are also automated, and if correct operation is confirmed, the user's terminal is notified of the progress and results.

[0648] This system also allows users to remotely monitor software progress within the data center. Users can check the system's operation from their smart devices via cloud services.

[0649] For example, when replacing new commercial database management software with open-source software, this system can be used to automatically modify all related queries and settings on the server and optimize the program. This allows even administrators with limited technical knowledge to work smoothly.

[0650] An example of a prompt message is: "Describe the steps to convert commercial database software in Company A's data center to open source. Focus particularly on how to remotely monitor the progress of the replacement work."

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

[0652] Step 1:

[0653] The server retrieves the source code from the user's terminal. This source code serves as input, and the server prepares to analyze the entire program based on it. The purpose of the analysis is to identify the commercial program components contained within the source code.

[0654] Step 2:

[0655] The server analyzes the acquired source code. The analysis process identifies commercial program components and interprets their dependencies. Based on the source code received as input, it constructs an abstract syntax tree and lists the commercial components. This information is used in the next step to select an alternative program.

[0656] Step 3:

[0657] The server uses a generative AI model to recommend open-source programs as alternatives to identified commercial program components. Using the analysis results as input, it generates candidates considering performance, compatibility, and usage conditions. The output is a list of recommended open-source programs.

[0658] Step 4:

[0659] The server automatically converts source code using recommended open-source programs. The input consists of a list and the original source code, and the server replaces the code based on these. Here, it modifies data structures and API calls as needed to generate new code.

[0660] Step 5:

[0661] The server performs tests on the converted source code. Using the converted code as input, it runs unit and integration tests to verify that the system functions correctly. The output is the test result, which is then reported to the user.

[0662] Step 6:

[0663] Users remotely monitor the progress using their devices. The devices receive notifications and logs from the server, which then display the conversion progress and test results. This allows users to verify that the migration has been successfully completed.

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

[0665] This invention relates to an AI agent system that recognizes user emotions and optimizes tasks during the migration process from commercial software to open-source software. The server first receives source code from the user and analyzes it to identify commercial software components. Then, it uses generative AI to suggest suitable open-source software candidates, while simultaneously acquiring the user's emotions in real time through an emotion engine and dynamically adjusting the suggestions to align with the user's expectations.

[0666] The sentiment engine analyzes how users react to suggestions. For example, if the user is satisfied with the suggested open-source software, the process proceeds as is; if dissatisfied, the suggestion is refined to explore other options. Furthermore, the server automatically converts the code to match the suggestion and then tests the converted code.

[0667] Based on the test results, the emotion engine measures user reactions and analyzes the feedback to improve user satisfaction with the results. The server uses this feedback to continuously improve and incorporate it into future suggestions and transformation processes. For example, when the server replaces a recognized commercial data analysis library in a project the user is involved in with a similar open-source library, it adjusts the presentation of different library candidates based on the user's favorable reactions, efficiently supporting the transition away from commercial licenses.

[0668] In this way, we support the transition to open-source software that reflects user sentiment, and realize a system that improves both efficiency and usability simultaneously.

[0669] The following describes the processing flow.

[0670] Step 1:

[0671] The user accesses the system and uploads the source code to be converted to the server. The server receives it and prepares it for analysis.

[0672] Step 2:

[0673] The server uses analysis tools to perform a detailed analysis of the source code and identify commercial software components. The analysis results include a list of software dependencies and external libraries used.

[0674] Step 3:

[0675] The server uses a generative AI to suggest alternative open-source software based on the analysis results. At this point, an emotion engine is activated to monitor the user's reaction and analyze whether the suggestions are satisfactory.

[0676] Step 4:

[0677] If the user's sentiment is determined to be positive towards the suggestion, the server automatically converts the source code with the suggested open-source software (OSS). If it is negative, the generating AI re-suggests other possible options and re-evaluates the user's satisfaction.

[0678] Step 5:

[0679] The server runs tests on the converted code. These tests include unit tests and integration tests to ensure the code works according to specifications.

[0680] Step 6:

[0681] After the test results are obtained, the device presents the results to the user as feedback. At this time, the emotion engine re-analyzes the user's response, evaluates the final satisfaction level, and collects data on areas for improvement next time.

[0682] Step 7:

[0683] The server uses the collected data to make adjustments to improve the efficiency of subsequent processes. This enables continuous process improvement.

[0684] (Example 2)

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

[0686] The migration process from commercial programs to open-source programs is complex and time-consuming, and can lead to decreased usability and inefficiency because it often proceeds without adequately considering user expectations and feelings. Furthermore, while moving away from commercial licenses is important, calculating the associated risks and costs is difficult. Therefore, a system is needed that enables efficient software migration while reflecting user sentiment.

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

[0688] In this invention, the server includes means for acquiring source code, means for analyzing the source code to identify commercial program components, means for proposing public source programs to replace the commercial program components, means for acquiring the user's emotional state in real time and dynamically adjusting the proposal, means for automatically converting the source code with the proposed public source programs, means for testing that the converted source code operates correctly, and means for analyzing user feedback based on the test results and improving the process. This enables an efficient and effective transition from commercial software to public source software while taking user emotions into consideration.

[0689] "Source code" is a collection of text-based instructions used to describe software or programs, which are then converted into a format that a computer can execute.

[0690] "Commercial program components" refer to parts or all of software that are provided under a commercial license and often incur a fee for use.

[0691] "Open source program" refers to any part or all of software provided under an open-source license that is free to use, modify, and redistribute.

[0692] "User emotional state" refers to the psychological and emotional responses a user exhibits to using a system or proposed software, and is typically measured in real time.

[0693] "Real-time acquisition" means that data and information are collected instantly at the moment processing takes place, and that they are obtained without delay.

[0694] "Dynamic adjustment" refers to a system automatically changing its content and settings in response to changing circumstances to maintain an optimal state.

[0695] "Automatic conversion" refers to a system or program mechanically processing data without human intervention, changing it into a different format or content.

[0696] "Testing for proper operation" refers to a series of verification processes to ensure that software operates as required and delivers the intended results.

[0697] "Analyzing feedback" refers to examining evaluations and opinions provided by users and using them to identify areas for system improvement.

[0698] In this invention, the server obtains source code provided by the user and performs analysis thereon. Here, specific code analysis tools are used to identify commercial program components. For example, general program analysis software may be used to extract source code dependencies.

[0699] After the analysis is complete, the server uses a generative AI model to suggest candidate open-source programs to replace the commercial program. This generative AI model is given instructions such as "Please suggest open-source alternatives to the commercial software currently in use."

[0700] The user's device displays a list of publicly available source programs suggested by the server, and the user makes a selection based on this list. The server can then acquire the user's responses and selections in real time using emotion recognition technology, and dynamically adjust its suggestions. Specifically, to improve user satisfaction, it uses facial recognition cameras and text analysis modules to evaluate the user's emotional state.

[0701] After the user selects candidates for publicly available source programs, the server automatically converts the source code based on these selections. The converted code is then tested in a test environment for functionality verification. A general-purpose testing framework is typically used during this process. This process ensures that all functions work correctly and that the functionality is as expected.

[0702] Finally, the server receives the test results as feedback from the user and analyzes it. Based on the data obtained, it improves future suggestions and the source code conversion process. This feedback process allows for a systematic improvement in user satisfaction.

[0703] This system is designed to facilitate a smooth transition from commercial to open-source programs while reflecting user sentiment, and to improve efficiency and usability.

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

[0705] Step 1:

[0706] The server obtains source code as input from the user. Specifically, the source code is provided via a URL specified by the user or through a file upload. The server records this obtained source code and prepares it for the next analysis step.

[0707] Step 2:

[0708] The server analyzes the acquired source code and identifies commercial program components. It receives the entire source code as input and uses program analysis tools to detect commercial components within the program. This process generates detailed data on dependencies and library usage. The identified commercial components are then utilized in the next proposed step.

[0709] Step 3:

[0710] The server uses a generative AI model to suggest open-source alternatives to commercial programs. Using information on the commercial program components identified as input, and based on the prompt "Suggest open-source alternatives to the commercial software currently in use," the generative AI model outputs candidate open-source programs. The suggested options are then presented to the user.

[0711] Step 4:

[0712] The terminal displays a list of publicly available source programs received from the server to the user. The user reviews the list and makes a selection. Based on the user's selection input, the server records the user's choice.

[0713] Step 5:

[0714] Based on user selection, the server automatically converts the source code. Using the user-selected public source program as input, it replaces commercial components using a code conversion tool. This process generates new source code as the conversion result.

[0715] Step 6:

[0716] The server tests the converted source code in a test environment. It receives the converted source code as input and uses a test framework to verify its operation. Output results are obtained that verify whether the functionality is executed correctly.

[0717] Step 7:

[0718] The server collects and analyzes user feedback based on test results. It takes test results and user ratings as input and uses an emotion engine to assess satisfaction. This analysis generates feedback information useful for future suggestions and process improvements.

[0719] (Application Example 2)

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

[0721] In the migration process from commercial software to open-source software, there is a need to present appropriate alternatives that take user sentiment into consideration, and to carry out the migration work efficiently and satisfactorily. Furthermore, challenges include proposing software that meets user expectations, automating code conversion, and ensuring its accuracy.

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

[0723] In this invention, the server includes means for acquiring source code, means for analyzing the source code to identify commercial software components, means for proposing open-source software to replace the commercial software components, means for acquiring the user's emotional state using emotion recognition means and dynamically adjusting the content of the proposal, means for automatically converting the source code with the proposed open-source software, and means for testing that the converted source code operates correctly. This enables an effective transition to open-source software that takes the user's emotions into consideration.

[0724] "Means of obtaining source code" refers to methods and techniques for obtaining a set of instructions used in the design and development of a program.

[0725] "Means for analyzing source code to identify commercial software components" refers to methods and techniques for thoroughly examining source code, extracting from it elements of commercially used software, and identifying them.

[0726] "Methods for proposing open-source software" refer to methods and technologies for presenting freely available software as an alternative to commercial software.

[0727] "Emotion recognition means" refers to methods and technologies for identifying and understanding a user's emotional state.

[0728] "Means of dynamic adjustment" refer to methods and techniques for automatically changing system or process settings in response to changes in circumstances or conditions.

[0729] "Means of automatic conversion" refers to methods and technologies for converting source code to different formats or specifications without human intervention.

[0730] "Testing methods" refer to the methods and techniques used to perform tests to ensure that source code or programs function correctly.

[0731] To implement this invention, a server-centric system is required. The server first acquires source code provided by the user and identifies commercial software components using the source code analysis platform "LibCST". Based on these identified components, a generative AI model is used to propose alternative open-source software. At this time, emotion recognition technology is used to acquire the user's emotional state in real time, and the open-source options presented by the generative AI are dynamically adjusted based on this data.

[0732] For sentiment recognition, the natural language processing library "TextBlob" is used. This allows sentiment values ​​to be extracted from user feedback and comments. If the proposed open-source software meets user expectations, the server automatically converts the source code. After this automatic conversion process, the server performs testing to verify that the converted code works correctly. The environment used for this testing includes Python and various testing frameworks.

[0733] As a concrete example, consider a system where, when a home robot open-sources software for a music playback service, it detects commercial libraries, suggests alternative open-source libraries through generative AI, and adjusts the candidates based on user feedback. In this process, the generative AI model can be instructed with a prompt such as: "Suggest open-source alternatives for voice recognition software used in home robots."

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

[0735] Step 1:

[0736] The server receives source code from the user. The input is the source code provided by the user, and the output is the source code data to be analyzed. In this process, the system confirms receipt of the source code and prepares to proceed to the next analysis stage.

[0737] Step 2:

[0738] The server uses the "LibCST" library to analyze the received source code and identify commercial software components. The input is the received source code, and the output is a list of commercial software components. Specifically, it generates an AST (Abstract Syntax Tree) to detect where commercial libraries and APIs are used.

[0739] Step 3:

[0740] The server uses a generative AI model to suggest open-source software alternatives to identified commercial software components. It takes a list of commercial software components as input and generates a list of open-source software candidates as output. Prompts are used to instruct the generative AI model and generate the optimal choice.

[0741] Step 4:

[0742] The server acquires the user's emotional state using emotion recognition mechanisms. Input is user feedback and comments, and output is an emotion value. Specifically, the TextBlob library is used to calculate the emotion value from the feedback text, and this information is used to adjust the suggested alternatives.

[0743] Step 5:

[0744] The server automatically converts source code based on the proposed open-source software. The input is information about the selected open-source software and the original source code, and the output is the converted source code. The conversion includes replacing commercial libraries and modifying corresponding code structures.

[0745] Step 6:

[0746] The server uses testing methods to verify that the converted source code works correctly. The input is the converted source code, and the output is the test results. The server ensures the accuracy of the code by checking for bugs and errors in the program and debugging as needed.

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

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

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

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

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

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

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

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

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

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

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

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

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

[0760] 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.

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

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

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

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

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

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

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

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

[0769] (Claim 1)

[0770] Means of obtaining the source code,

[0771] A means for analyzing the aforementioned source code to identify commercial software components,

[0772] A means for proposing open-source software to replace the aforementioned commercial software component,

[0773] The proposed open-source software provides a means for automatically converting the source code,

[0774] A means for testing that the converted source code works correctly,

[0775] A system that includes this.

[0776] (Claim 2)

[0777] The system according to claim 1, wherein the source code analysis includes means for analyzing software dependencies.

[0778] (Claim 3)

[0779] The system according to claim 1, wherein, with respect to the proposed open-source software, means include considering performance, compatibility, and licensing conditions as selection criteria.

[0780] "Example 1"

[0781] (Claim 1)

[0782] Means of collecting code,

[0783] A means for analyzing the aforementioned code and identifying commercial program elements,

[0784] Means for selecting an open access program that can replace the aforementioned commercial program elements,

[0785] A means for automatically modifying the code using the selected open access program,

[0786] Means for verifying that the modified code works correctly,

[0787] In the analysis of the aforementioned code, a means for recommending open access programs while considering selection criteria using a generative artificial intelligence model,

[0788] A means for reporting the results of applying the aforementioned recommended program,

[0789] A system that includes this.

[0790] (Claim 2)

[0791] The system according to claim 1, further comprising means for analyzing program dependencies in the analysis of the code.

[0792] (Claim 3)

[0793] The system according to claim 1, comprising means for considering performance, compatibility, and usage permission conditions as criteria for selecting the open access program.

[0794] "Application Example 1"

[0795] (Claim 1)

[0796] A device for collecting source code,

[0797] A device that analyzes the aforementioned source code to identify commercial program components,

[0798] A device that recommends open-source programs to replace the aforementioned commercial program components,

[0799] A device that automatically converts the source code using the aforementioned recommended open-source program,

[0800] A device for verifying that the converted source code functions correctly,

[0801] A device including means for remotely monitoring software progress within a data center,

[0802] A system that includes this.

[0803] (Claim 2)

[0804] The system according to claim 1, further comprising a device for interpreting program dependencies in the source code analysis.

[0805] (Claim 3)

[0806] The system according to claim 1, comprising a device that considers performance, compatibility, and usage conditions as selection criteria for the aforementioned open-source program.

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

[0808] (Claim 1)

[0809] Means of obtaining the source code,

[0810] Means for analyzing the aforementioned source code to identify commercial program components,

[0811] A means for proposing an open source program to replace the aforementioned commercial program components,

[0812] A means of acquiring the user's emotional state in real time and dynamically adjusting the suggested content,

[0813] The proposed public source program provides a means for automatically converting the source code,

[0814] A means for testing that the converted source code works correctly,

[0815] A means of analyzing user feedback based on test results and improving the process,

[0816] A system that includes this.

[0817] (Claim 2)

[0818] The system according to claim 1, further comprising means for analyzing program dependencies in the source code analysis.

[0819] (Claim 3)

[0820] The system according to claim 1, comprising means for considering performance, compatibility, and licensing conditions as selection criteria for the proposed publicly available source program.

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

[0822] (Claim 1)

[0823] Means of obtaining the source code,

[0824] A means for analyzing the aforementioned source code to identify commercial software components,

[0825] A means for proposing open-source software to replace the aforementioned commercial software components,

[0826] A means for acquiring the user's emotional state using emotion recognition means and dynamically adjusting the content of the proposal,

[0827] The proposed open-source software provides a means for automatically converting the source code,

[0828] A means for testing that the converted source code works correctly,

[0829] A system that includes this.

[0830] (Claim 2)

[0831] The system according to claim 1, wherein the source code analysis includes means for analyzing software dependencies.

[0832] (Claim 3)

[0833] The system according to claim 1, wherein, with respect to the proposed open-source software, means include considering performance, compatibility, and licensing conditions as selection criteria. [Explanation of Symbols]

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

Claims

1. A device for collecting source code, A device that analyzes the aforementioned source code to identify commercial program components, A device that recommends open-source programs to replace the aforementioned commercial program components, A device that automatically converts the source code using the aforementioned recommended open-source program, A device for verifying that the converted source code functions correctly, A device including means for remotely monitoring software progress within a data center, A system that includes this.

2. The system according to claim 1, further comprising a device for interpreting program dependencies in the source code analysis.

3. The system according to claim 1, comprising a device that considers performance, compatibility, and usage conditions as selection criteria for the aforementioned open-source program.

Images