system

Abstract

We provide the system. [Solution] A system that automatically manages the dependencies of software components, A means of obtaining library information from an external data area and storing it in an internal database, A means for analyzing collected library information, generating and matching dependency graphs, A means for detecting potential defects and generating necessary corrective measures, A means to automatically update the source code based on the generated revision proposals, A means of running tests to determine the validity of the updated code, A system including means for analyzing the aforementioned test results and reporting the verification results.

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, and includes steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to an explanation of a character of the chatbot, 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 modern software development, the update of libraries and the accompanying management of dependencies are major issues. The update of libraries often causes dependencies to break down and the operation of the system to become unstable. In such a situation, engineers need to spend a huge amount of time checking the compatibility of libraries and detecting defects, which significantly reduces the development efficiency. Therefore, there is a need for a system that can automate the library update process and quickly detect and correct defects caused by dependencies.

Means for Solving the Problems

[0005] The present invention solves the above problems by providing a system for automatically managing the dependencies of software components. Specifically, it includes means for acquiring library information from an external data area and storing it in an internal database. Furthermore, it includes means for analyzing the collected library information, generating and comparing a dependency graph on the system, detecting potential defects, and generating proposed fixes. It also automatically updates the source code based on the generated proposed fixes, and then performs tests to determine the validity of the updated code. Finally, it achieves efficient library management and system operation through a series of processes that analyze the test results and report them to the user.

[0006] "Software components" is a technical concept that refers to the programs, libraries, and related components necessary for software to function.

[0007] "Dependency" refers to the interrelationships that one software component requires from other software components in order to operate or function.

[0008] "External data area" refers to storage locations for data that is not stored internally within an organization, such as cloud storage or repositories accessible via the internet or network.

[0009] "Library information" refers to metadata related to the version and dependencies of a collection of reusable code written in a specific programming language.

[0010] An "internal database" refers to a location where data managed on an internal network is stored for use by applications and systems.

[0011] A "dependency graph" is a network diagram that visually represents the interdependencies between software components.

[0012] A "potential defect" refers to a software flaw or anomaly that is not currently apparent but could potentially cause problems in the future.

[0013] A "revised plan" refers to specific countermeasures or proposed changes formulated to resolve identified defects or problems.

[0014] "Validity testing" refers to a series of evaluation processes conducted to verify and confirm that the functions and performance of software operate as intended. [Brief explanation of the drawing]

[0015] [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] It is a sequence diagram showing the processing flow of the data processing system in Application Example 1. [Figure 13] It is a sequence diagram showing the processing flow of the data processing system in Example 2 when the emotion engine is combined. [Figure 14] It is a sequence diagram showing the processing flow of the data processing system in Application Example 2 when the emotion engine is combined.

Embodiments for Carrying Out the Invention

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

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

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

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

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

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

[0022] 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."

[0023] [First Embodiment]

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

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

[0026] 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).

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

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

[0029] The output device 40 includes a display 40A and a speaker 40B, and presents data to the user 20 by outputting the data in a form 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.

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

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

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

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

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

[0035] 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".

[0036] The present invention is a system for automatically managing the dependencies of software components, and its program processes as follows.

[0037] First, the server retrieves library information from an external data area accessible via the internet. This includes metadata such as library version information and dependency information. The server organizes and stores the retrieved information in an internal database to maintain up-to-date information.

[0038] Next, the terminal generates a dependency graph using library information stored on the server. This allows for the visualization and analysis of the interdependencies between each software component. The terminal analyzes this dependency graph and uses an AI model to detect potential bugs.

[0039] The AI ​​model identifies potential bugs caused by library updates and generates necessary fixes. Based on these fixes, the device automatically updates its source code to conform to the latest library specifications. This ensures that the system continues to operate stably.

[0040] The user runs tests to validate the modified code. The terminal automates this testing process and aggregates the test results to the server. The server analyzes the test results to confirm whether the bug has been resolved.

[0041] Finally, the server reports the test results and fixes to the user. If the user approves based on this report, the server deploys the updated code to the production environment and resumes normal system operation.

[0042] These processes ensure that the latest state of libraries is always maintained, preventing system instability caused by dependencies. This invention frees users from the complex manual tasks associated with library updates, enabling more efficient and reliable system operation.

[0043] The following describes the processing flow.

[0044] Step 1:

[0045] The server periodically accesses an external data area to retrieve the latest library information. This information includes metadata about library versions, release notes, and dependencies. The server stores this data in an internal database and organizes the information for easy access by administrators.

[0046] Step 2:

[0047] The terminal uses library information obtained from the server to generate a dependency graph between the installed software components. This visualizes the interdependencies between libraries and each component within the system, allowing for the identification of potential problems.

[0048] Step 3:

[0049] The device inputs the generated dependency graph into the AI ​​model to detect potential bugs associated with library updates. The AI ​​model predicts problems based on past data and evaluates the likelihood of specific bugs.

[0050] Step 4:

[0051] The device generates suggested fixes for bugs identified by the AI ​​model. Based on these suggested fixes, the device automatically updates the source code to conform to the new library specifications. The code modifications are performed according to the optimal method recommended by the AI ​​model.

[0052] Step 5:

[0053] The user runs automatically generated tests to verify the validity of the code updated by the device. The device monitors the test execution and records the results. This testing process ensures that the modified code functions as intended.

[0054] Step 6:

[0055] The server aggregates the test results, analyzes them, and checks the status of resolving possible bugs. The server reports the analysis results to the user as detailed feedback and suggests further actions.

[0056] Step 7:

[0057] Once user approval is received, the server deploys the updated code to the production environment. This resumes system operation based on the latest library specifications, ensuring system stability and efficiency.

[0058] (Example 1)

[0059] 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."

[0060] In existing software development, the increasing complexity of dependencies between software components makes manual management extremely difficult due to library updates and changes in dependencies. This increases the risk of system instability and defects, resulting in decreased development efficiency and reliability. Furthermore, the lack of means to identify potential defects in advance means that countermeasures cannot be taken until problems become apparent.

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

[0062] In this invention, the server includes means for acquiring software information from an information area and storing it in a storage device, means for analyzing the collected software information and generating and checking dependency structures, and means for detecting potential problems and generating optimal solutions using a machine learning model. This makes it possible to keep the dependencies of software components up-to-date and optimal at all times, and the automated system enables proactive prevention of defects and expedited resolution.

[0063] "Information area" refers to an external or internal storage device that holds software information, including repositories accessible via a network.

[0064] "Software information" refers to data about software components, including version information and dependency metadata.

[0065] "Storage device" refers to an internal database or storage medium used to store collected information.

[0066] A "dependency structure" is a data structure that shows the interrelationships between multiple software elements, and includes graph formats.

[0067] A "machine learning model" refers to an algorithm or system that learns from past data and uses it to make predictions and analyses in new situations.

[0068] "Potential problems" refer to elements in the software that may have incompatibilities or defects, and it is desirable to detect them in advance.

[0069] A "proposal for correction" refers to a specific method or proposed change to resolve the detected problem, and is used as part of the automated update process.

[0070] This invention operates as a system that automatically manages the dependencies of software components. The entire system mainly consists of a server, terminals, and users.

[0071] The server retrieves the latest software information from software repositories accessible via the internet. This information includes version information and dependency metadata. The server stores the retrieved information in its internal storage and manages and updates it using a database. Specifically, SQL databases or NoSQL storage may be used.

[0072] The terminal uses software information stored on the server to form a dependency structure. This dependency structure is implemented as a graph representing the interrelationships between software components. The terminal generates this graph using a graph library such as NetworkX and then analyzes it.

[0073] Furthermore, the device uses a generative AI model to detect potential problems. This AI model is based on machine learning algorithms and uses the trained data to determine the risk of incompatibilities and defects caused by software updates. The AI ​​model generates suggested fixes for predicted problems and automatically updates the code based on those fixes.

[0074] Users verify the validity of updated code through automated tests run on their devices. Continuous integration (CI) tools are used for testing, and test results are centrally managed on the server. This allows for rapid evaluation of whether issues have been resolved and reports are provided to the user.

[0075] For example, if a project uses a Python library, the server retrieves new library information from the Python Package Index (PyPI), and the terminal updates the dependency structure based on that information. The AI ​​model detects incompatible function calls and generates alternative solutions. The terminal executes these suggestions, and the user verifies the results with automated tests.

[0076] An example of a prompt for the generated AI model is, "Based on the dependency structure, identify potential bugs that may arise from library updates and provide proposed fixes." This system enables users to operate software efficiently and reliably.

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

[0078] Step 1:

[0079] The server connects to the software repository via the network. Its purpose is to retrieve the latest library information. The repository's API endpoint URL is used as input. The server sends an HTTP request and retrieves library version information and dependency metadata in JSON format. This JSON data is then parsed, and the necessary information is extracted. The output is a set of the parsed library data.

[0080] Step 2:

[0081] The server stores the retrieved library information in storage. The input is the library data retrieved in step 1. The server saves this to an SQL database and updates the existing information. In particular, if there is new version information, it avoids duplication with old data and adds the new information. The output is the updated state of the database.

[0082] Step 3:

[0083] The terminal retrieves the latest library information from the server's database. The input is the library dataset provided by the server. Based on this data, the terminal generates a dependency structure. In this process, the terminal uses a dedicated library such as NetworkX to create a graph of the relationships between software components. The output is the dependency graph.

[0084] Step 4:

[0085] The device analyzes the dependency graph and identifies potential problems using a generative AI model. The input is the generated dependency graph. The AI ​​model uses algorithms learned from historical data to predict incompatibilities and potential bugs. This analysis generates specific corrective action plans. The output is a list of potential problems and their corresponding solutions.

[0086] Step 5:

[0087] The terminal automatically updates the source code based on the suggested modifications from the AI ​​model. The input is the suggested modifications provided by the AI ​​model. The terminal applies the modifications to the codebase and automatically performs necessary library updates and code edits. The output is the updated source code.

[0088] Step 6:

[0089] The user runs automated tests provided by the terminal to verify the reliability of the updated code. The inputs are the updated source code and the test script. The terminal runs the tests and outputs the results. The test results are output as a success or error report.

[0090] Step 7:

[0091] The server collects and analyzes test results before reporting them to the user. The input is test result data from the terminal. The server analyzes this data, aggregates the results, and creates a report. The output is a detailed report of the test results, which the user can review.

[0092] Step 8:

[0093] The user approves the deployment of the code to the production environment based on the test results received from the server. The input is the test result report from the server. After approval, the server automatically deploys the code to the production environment. The output is the successfully deployed system. This entire process allows the system to maintain continuous and stable operation.

[0094] (Application Example 1)

[0095] 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."

[0096] In today's complex software systems, accurately managing the dependencies between software components and keeping them constantly up-to-date is a significant burden for operators. Furthermore, quickly identifying and resolving potential bugs arising from library updates is also challenging. Moreover, real-time monitoring and support for stable operation are needed to efficiently perform these tasks.

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

[0098] In this invention, the server includes means for acquiring software library information from an external information area and storing it in an internal information management device; means for analyzing the collected software library information and generating and comparing interdependency graphs; means for detecting potential defects and generating necessary corrective measures; means for monitoring the status of software libraries in real time and supporting operational stability through data analysis; and means for notifying update information via a user interface. This enables operators to easily manage software dependencies and quickly identify and resolve potential defects.

[0099] "Software components" are individual programs or modules that make up a system, and are fundamental units that provide specific functions or services.

[0100] A "dependency" is a relationship that describes a state in which one software component operates in relation to another element.

[0101] The "external information area" is a location where information that can be accessed via a network such as the internet is stored.

[0102] A "software library" is a collection of code that provides specific functionality, and it is a set of programs that can be reused by developers by calling that functionality.

[0103] A "dependency graph" is a diagram that visually represents the dependencies between software components, clearly illustrating the interrelationships between each element.

[0104] A "malfunction" is a software error or defect that causes unintended behavior or results.

[0105] A "proposal for correction" is a specific instruction for change or improvement proposed to resolve a problem.

[0106] "Real-time monitoring" refers to activities that involve continuously observing data and having the ability to respond immediately, so that the latest status can always be understood.

[0107] "Operational stability" refers to a state in which a system continues to function correctly without unintended shutdowns or errors.

[0108] "Data analysis means" refers to a series of processes or methods for deriving useful insights using collected information.

[0109] To implement this invention, a system consisting of a server and a terminal is used. The server acquires software library information from an external information area and stores it in an internal information management device. The software used is Node.js, which performs real-time data processing. The data is exchanged in JSON format and managed using MongoDB. The server utilizes a generative AI model built using TENSORFLOW® to detect potential defects and generate proposed corrections.

[0110] The device is developed using React Native and provides the user interface. The device displays a real-time interdependency graph generated by D3.js. Users can monitor the software's state through this graph and apply suggested fixes via the interface as needed. Furthermore, the device runs automated tests and sends the results to the server.

[0111] As a concrete example, suppose a data center operator manages the system's library status using a terminal. When the system updates a specified library, the AI ​​automatically predicts potential problems and provides appropriate solutions. This ensures the system remains stable. Furthermore, by inputting a prompt such as, "The system may have become unstable after installing the latest library. Please identify dependency issues and suggest solutions," the AI ​​model can provide rapid assistance.

[0112] This allows users to achieve efficient operation and manage library dependencies.

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

[0114] Step 1:

[0115] The server accesses an external information area to retrieve software library information. The input is a list of URLs for the external information area, and data is retrieved using a REST API. The output is library version information and dependency metadata. The retrieved data is in JSON format and is stored in MongoDB, the internal information management system.

[0116] Step 2:

[0117] The server analyzes the collected library information and generates an interdependency graph. The input is library information stored in MongoDB. The output is graph data that visualizes the dependencies between libraries. This process uses a Python library, and the graph is drawn using D3.js.

[0118] Step 3:

[0119] The terminal displays an interdependency graph generated through the user interface. When the user detects an anomaly, they can investigate it on the screen. The input is graph data sent from the server, and the output is a visualized graph on the user interface.

[0120] Step 4:

[0121] The server uses a generative AI model to detect potential bugs and generate suggested fixes. The input consists of a generated dependency graph and change history data. The output is a list of identified bugs and their corresponding suggested fixes. This process utilizes TensorFlow for AI-driven bug detection.

[0122] Step 5:

[0123] The terminal receives AI-generated correction suggestions and presents them on the user interface. The user can review the suggested corrections and apply them as needed. The input is the correction suggestions sent from the server, and the output is the state in which the correction suggestions are presented to the user.

[0124] Step 6:

[0125] The terminal runs automated tests and sends the results to the server. The input is the modified software code based on the applied fixes. The output is log data of the test results. The tests are performed quickly using CI / CD tools.

[0126] Step 7:

[0127] The server analyzes the test results and reports the verification results to the user. The input is log data of the test results sent from the terminal. The output is the analyzed verification results and their report. The results are displayed through the user interface, allowing the user to make a final confirmation.

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

[0129] This invention combines a system that automatically manages the dependencies of software components with an emotion engine that recognizes user emotions. This program processes as follows:

[0130] First, the server retrieves library information from an external data area via the internet. This information is stored in an internal database, where library versions and dependencies are managed. This allows the server to maintain the latest library information in real time and make it available to users.

[0131] The terminal generates a dependency graph using library information stored on the server and analyzes it. This graph is used to visualize the interrelationships between each library and to clearly show the dependencies between software components. If a potential bug is detected, the AI ​​model generates a suggested fix. At this stage, the terminal automatically updates the source code to fix the bug and avoid the problem.

[0132] In this process, users utilize the functions of the emotion engine. The emotion engine analyzes the user's emotions and combines this emotional information to adjust the interface when reporting bugs or suggesting fixes. As a result, it reduces user stress and provides a mechanism that allows users to operate the system more comfortably.

[0133] For example, if a user expresses dissatisfaction with a bug after a library update, the sentiment engine works to alleviate that dissatisfaction by providing a more detailed explanation of the proposed fix or prioritizing the provision of relevant information. Similarly, if a user feels unsure about operating the system, the sentiment engine provides guidance to improve the user experience.

[0134] Finally, the server analyzes the test results and reports the final verification findings to the user. This report includes feedback from the emotion engine and suggests solutions for any areas that need improvement. This ensures that the system is always operating optimally and meeting user needs.

[0135] The following describes the processing flow.

[0136] Step 1:

[0137] The server accesses an external data area and retrieves the latest library information via the internet. This information includes library version information and dependency metadata, which is stored in an internal database. The server keeps this database up-to-date to prepare for subsequent processing.

[0138] Step 2:

[0139] The terminal uses library information provided by the server to generate a dependency graph between software components within the system. The terminal analyzes this graph to understand in detail which components depend on which other libraries.

[0140] Step 3:

[0141] The device uses an AI model to analyze the generated dependency graph and detect potential bugs. This AI model refers to historical data to predict the likelihood of bugs caused by library updates.

[0142] Step 4:

[0143] The emotion engine analyzes the user's emotions in real time. When a user shows an emotional response to the system, the device receives feedback from the emotion engine and adjusts the priority of reports and how details are presented.

[0144] Step 5:

[0145] The device generates suggested fixes for bugs identified by the AI ​​model. Based on these, the device automatically updates the source code to comply with the new library specifications. This update process is carried out appropriately, taking into account the user's sentiment information.

[0146] Step 6:

[0147] The user runs tests to verify the validity of the code updates performed by the device. The user receives feedback from the sentiment engine and can adjust the interface as needed.

[0148] Step 7:

[0149] The server aggregates and analyzes the test results to confirm whether the bugs have been resolved. Along with the analysis results, the server provides the user with a report that includes feedback obtained from user sentiment data.

[0150] Step 8:

[0151] Once user approval is received, the server deploys the updated source code to the production environment and resumes normal system operation. During this process, it is also possible to continuously suggest improvements based on the user's emotional state.

[0152] (Example 2)

[0153] 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 will be referred to as the "terminal."

[0154] In software development, there is a growing need to automatically manage the increasingly complex dependencies between software components and to quickly detect and correct potential problems. Furthermore, optimizing the interface while considering the emotions of system users is also crucial. This invention aims to provide a system that effectively solves these problems.

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

[0156] In this invention, the server includes means for acquiring software component information from an external information area and storing it in an internal information recording device, means for analyzing the collected software component information and generating and comparing dependency diagrams, and means for analyzing user emotions and adaptively adjusting the interface. This makes it possible to efficiently manage software component dependencies, improve the user experience, and quickly identify and correct potential problems.

[0157] The "external information domain" is a source of information for collecting component information that can be accessed via a global information network.

[0158] "Software component information" refers to data containing information about the components of software, including version and dependency information.

[0159] An "internal information recording device" is a database or storage device used to store and manage software component information.

[0160] A "dependency diagram" is a diagram used to visualize the interrelationships between software components, and is a graph that shows the dependencies between them.

[0161] An "interface" is a point of contact for information exchange between a user and a system.

[0162] "Analyzing emotions" refers to the process of evaluating a user's emotional state from data and making decisions based on that information.

[0163] "Adaptively adjusting" means changing the behavior of an interface or system according to the situation or requirements.

[0164] "Rapidly identifying and fixing problems" refers to quickly detecting potential defects or issues and making appropriate corrections.

[0165] This invention provides a system that efficiently manages the dependencies of software components and offers an interface that responds to user emotions. This system operates based on the interaction between the server, terminal, and user.

[0166] The server retrieves software component information from an external information area via the internet. In this process, the server uses a REST API to collect publicly available component information. The collected information is received in JSON format and stored in a database. This database is used to manage library version information and dependencies.

[0167] The terminal generates a dependency diagram using this software component information stored on the server. The terminal uses graph database software (e.g., Neo4j) to create nodes for each software component and edges indicating their dependencies. This information is then plotted as a graph using a visualization tool (e.g., D3.js).

[0168] Users receive support through an emotion engine during this process. The emotion engine has the ability to analyze emotions from the user's input and system operation history. If a user shows frustration while using the system, for example, the emotion engine will adjust the interface and work to reduce stress. This allows users to use the system comfortably.

[0169] A concrete example is a case where a user encounters a bug after a library update and expresses dissatisfaction. In this case, the emotion engine provides a detailed explanation of the proposed bug fix and prioritizes the provision of relevant information. Furthermore, because this system utilizes a generative AI model, it has the ability to propose appropriate solutions tailored to the user's requests.

[0170] A concrete example of a prompt message would be, "Please tell me how to retrieve the latest component information, analyze the dependency diagram, and generate suggested fixes for the detected defects." This allows the system to respond quickly to user requests and provide the optimal solution.

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

[0172] Step 1:

[0173] The server retrieves software component information from an external information area. In this step, it receives the URL and authentication information of an external API as input and obtains a dataset of software components in JSON format as output. Specifically, the server communicates over the network via a REST API, retrieves library information from the specified repository, and writes it to the database.

[0174] Step 2:

[0175] The terminal generates a dependency diagram based on software component information obtained from the server. The input is software component information obtained from a database, and the output is graph data showing the dependencies. In this process, nodes and edges are generated in a graph database (e.g., Neo4j) to visually structure the relationships between components.

[0176] Step 3:

[0177] The terminal analyzes the generated dependency diagram to detect potential problems. The input is the data from the dependency graph, and the output is a list of problems and their details. In this step, machine learning algorithms are used to scan the graph and compare it with existing data models to identify inconsistencies and potential bugs.

[0178] Step 4:

[0179] The AI ​​model generates suggested solutions based on the detected problems. The input is a list of problems, and the output is specific suggested solutions. The generating AI model utilizes natural language processing techniques to propose the optimal solution, referencing past correction history and solutions to similar problems.

[0180] Step 5:

[0181] The device automatically updates the source code based on the proposed modifications generated by the AI ​​model. The input is the proposed modifications, and the output is the updated source code. This process applies the suggested changes to the existing code, ensuring code consistency and accuracy.

[0182] Step 6:

[0183] The server performs tests on the updated source code. The input is the updated source code, and the output is the test results. At this stage, unit tests and integration tests are performed through the CI / CD pipeline to confirm that the update functions as expected.

[0184] Step 7:

[0185] The server analyzes the test results and reports the final verification results to the user. The input is test result data, and the output is a verification report. Specifically, it aggregates the test results, generates a report including the cause and countermeasures if there are any problems, and notifies the user.

[0186] Step 8:

[0187] The user adjusts the system interface using an emotion engine. The input is the user's emotional data, and the output is the adjusted interface settings. The emotion engine analyzes the user's emotional state and adjusts the tone and amount of information in the interface as needed to optimize the user experience.

[0188] (Application Example 2)

[0189] 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."

[0190] In modern software development, managing component dependencies is complex and often leads to potential bugs. Furthermore, users frequently experience stress and anxiety during operation, in addition to these technical issues, which acts as a barrier to software use. Therefore, there is a need for technologies that simultaneously achieve effective dependency management and improved user experience.

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

[0192] In this invention, the server includes means for acquiring library information from an external information storage area and storing it in an internal information storage area; means for analyzing the collected library information and generating and comparing dependency graphs; means for detecting potential defects and generating necessary corrective measures; and means for analyzing user emotions and dynamically adjusting the interface. This enables efficient dependency management of software and reduces stress on the user while improving the user experience.

[0193] "Software components" refer to individual program parts that make up a program, such as libraries, modules, and frameworks.

[0194] A "dependency" refers to a relationship where one software component depends on another and operates in relation to them.

[0195] An "external information storage area" is a location on the internet or a network where various data and library information are stored.

[0196] "Library information" refers to data that includes version information and dependencies of program components and modules used in software development.

[0197] The "internal information storage area" is a storage area for temporarily or permanently storing data necessary for use within the system.

[0198] A "malfunction" refers to a problem where software does not function correctly or does not produce the expected results.

[0199] A "proposal for correction" refers to a specific plan or proposed change aimed at resolving a detected defect.

[0200] "Program code" refers to a set of instructions written to build software, or text used to give commands to a computer processor.

[0201] "Testing" refers to a specific testing process conducted to verify that software operates according to specifications.

[0202] "User emotions" refers to the emotions and psychological states expressed by users when using software.

[0203] An "interface" is an element that defines the screen display and operability when a user interacts with software.

[0204] "Stress reduction" refers to measures and functions designed to lower the psychological burden that users experience when using software.

[0205] This invention is a system for dynamically adjusting the interface by analyzing user emotions while efficiently managing the dependencies of software components.

[0206] The server retrieves library information from an external information storage area via the information and communication network and stores this data in its internal information storage unit. This information is important because it provides the data necessary for managing dependencies and analyzing defects.

[0207] The terminal analyzes library information obtained from the server, generates a dependency graph, and clearly shows the relationships between each library. This allows for the detection of potential bugs and the generation of suggested fixes as needed. Based on these suggested fixes, the program code is automatically updated, providing users with a highly reliable system.

[0208] Users operate the software through their devices, and during this process, an emotion analysis engine analyzes the user's facial expressions and voice tone to understand their emotions. Based on this emotional information, the interface is dynamically adjusted to improve the user experience. If the user feels stressed, the interface becomes more user-friendly; if they feel anxious, detailed guides and supplementary information are provided to reduce the psychological burden of using the software.

[0209] As a concrete example, if this system is implemented in a smartphone application, when an error occurs while the user is updating a library, the emotion engine can detect from the user's facial expression that they are experiencing stress. In this case, the app automatically displays a detailed explanation of the error and troubleshooting steps to alleviate the user's anxiety. It also provides the user with interactive guidance as needed. At this point, a generative AI model is used to determine the optimal approach based on the user's state.

[0210] An example of a prompt might be: "If the user feels uneasy during payment, suggest ways to display additional information and improve the user experience. How do you analyze the user's emotions and respond?"

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

[0212] Step 1:

[0213] The server retrieves library information from an external information storage area via an information and communication network. The input is library information from the external storage area, and the output is data stored in the internal information storage unit. The data is retrieved in real time and organized to maintain the latest library information.

[0214] Step 2:

[0215] The terminal receives library information provided by the server, analyzes that data, and generates a dependency graph. The input is library information obtained from the server, and the output is the generated dependency graph. The analysis checks the links of each library in the database and models their relationships in a visually understandable way.

[0216] Step 3:

[0217] The device uses the generated dependency graph to detect potential bugs and generate suggested fixes. The input is the dependency graph, and the output is the bugs and their suggested fixes. Here, a generative AI model is used to analyze bug patterns and calculate the optimal fix procedure.

[0218] Step 4:

[0219] The terminal automatically updates the program code based on the generated correction proposal. The input is the correction proposal, and the output is the updated program code. The system directly modifies the code and records the changes that are reflected.

[0220] Step 5:

[0221] The terminal performs tests to determine the validity of the updated code. The input is the updated program code, and the output is the test result. The tests verify operation in specific scenarios and collect data to confirm normal operation.

[0222] Step 6:

[0223] The server analyzes the test results and reports the findings to the user. The input is the test results, and the output is the report to the user. Using an emotion engine, the report is tailored to the user's situation and presented in text and graphics.

[0224] Step 7:

[0225] While the user operates the system through their device, their emotions are analyzed by an emotion analysis engine. The input is the user's facial expressions and voice during operation, and the output is the analyzed emotion data. Based on the emotion data, the interface is adjusted, and necessary guides and information are displayed.

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

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

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

[0229] [Second Embodiment]

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

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

[0232] 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).

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

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

[0235] 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).

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

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

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

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

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

[0241] 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".

[0242] The present invention is a system for automatically managing the dependencies of software components, and its program processes as follows.

[0243] First, the server retrieves library information from an external data area accessible via the internet. This includes metadata such as library version information and dependency information. The server organizes and stores the retrieved information in an internal database to maintain up-to-date information.

[0244] Next, the terminal generates a dependency graph using library information stored on the server. This allows for the visualization and analysis of the interdependencies between each software component. The terminal analyzes this dependency graph and uses an AI model to detect potential bugs.

[0245] The AI ​​model identifies potential bugs caused by library updates and generates necessary fixes. Based on these fixes, the device automatically updates its source code to conform to the latest library specifications. This ensures that the system continues to operate stably.

[0246] The user runs tests to validate the modified code. The terminal automates this testing process and aggregates the test results to the server. The server analyzes the test results to confirm whether the bug has been resolved.

[0247] Finally, the server reports the test results and fixes to the user. If the user approves based on this report, the server deploys the updated code to the production environment and resumes normal system operation.

[0248] These processes ensure that the latest state of libraries is always maintained, preventing system instability caused by dependencies. This invention frees users from the complex manual tasks associated with library updates, enabling more efficient and reliable system operation.

[0249] The following describes the processing flow.

[0250] Step 1:

[0251] The server periodically accesses an external data area to retrieve the latest library information. This information includes metadata about library versions, release notes, and dependencies. The server stores this data in an internal database and organizes the information for easy access by administrators.

[0252] Step 2:

[0253] The terminal uses library information obtained from the server to generate a dependency graph between the installed software components. This visualizes the interdependencies between libraries and each component within the system, allowing for the identification of potential problems.

[0254] Step 3:

[0255] The device inputs the generated dependency graph into the AI ​​model to detect potential bugs associated with library updates. The AI ​​model predicts problems based on past data and evaluates the likelihood of specific bugs.

[0256] Step 4:

[0257] The device generates suggested fixes for bugs identified by the AI ​​model. Based on these suggested fixes, the device automatically updates the source code to conform to the new library specifications. The code modifications are performed according to the optimal method recommended by the AI ​​model.

[0258] Step 5:

[0259] The user runs automatically generated tests to verify the validity of the code updated by the device. The device monitors the test execution and records the results. This testing process ensures that the modified code functions as intended.

[0260] Step 6:

[0261] The server aggregates the test results, analyzes them, and checks the status of resolving possible bugs. The server reports the analysis results to the user as detailed feedback and suggests further actions.

[0262] Step 7:

[0263] Once user approval is received, the server deploys the updated code to the production environment. This resumes system operation based on the latest library specifications, ensuring system stability and efficiency.

[0264] (Example 1)

[0265] 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."

[0266] In existing software development, the increasing complexity of dependencies between software components makes manual management extremely difficult due to library updates and changes in dependencies. This increases the risk of system instability and defects, resulting in decreased development efficiency and reliability. Furthermore, the lack of means to identify potential defects in advance means that countermeasures cannot be taken until problems become apparent.

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

[0268] In this invention, the server includes means for acquiring software information from an information area and storing it in a storage device, means for analyzing the collected software information and generating and checking dependency structures, and means for detecting potential problems and generating optimal solutions using a machine learning model. This makes it possible to keep the dependencies of software components up-to-date and optimal at all times, and the automated system enables proactive prevention of defects and expedited resolution.

[0269] "Information area" refers to an external or internal storage device that holds software information, including repositories accessible via a network.

[0270] "Software information" refers to data about software components, including version information and dependency metadata.

[0271] "Storage device" refers to an internal database or storage medium used to store collected information.

[0272] A "dependency structure" is a data structure that shows the interrelationships between multiple software elements, and includes graph formats.

[0273] A "machine learning model" refers to an algorithm or system that learns from past data and uses it to make predictions and analyses in new situations.

[0274] "Potential problems" refer to elements in the software that may have incompatibilities or defects, and it is desirable to detect them in advance.

[0275] A "proposal for correction" refers to a specific method or proposed change to resolve the detected problem, and is used as part of the automated update process.

[0276] This invention operates as a system that automatically manages the dependencies of software components. The entire system mainly consists of a server, terminals, and users.

[0277] The server retrieves the latest software information from software repositories accessible via the internet. This information includes version information and dependency metadata. The server stores the retrieved information in its internal storage and manages and updates it using a database. Specifically, SQL databases or NoSQL storage may be used.

[0278] The terminal uses software information stored on the server to form a dependency structure. This dependency structure is implemented as a graph representing the interrelationships between software components. The terminal generates this graph using a graph library such as NetworkX and then analyzes it.

[0279] Furthermore, the terminal uses a generative AI model to detect potential problems. This AI model is based on machine learning algorithms and, based on the trained data, determines the risk of incompatibility or defects due to software updates. The AI model generates amendments for the predicted problems and automatically updates the code based on those amendments.

[0280] The user confirms the validity of the updated code through automated tests executed by the terminal. Continuous Integration (CI) tools are used for the tests, and the test results are integratedly managed on the server. This enables a quick assessment of whether the problem has been resolved and reporting to the user.

[0281] As a specific example, in the case of a project using a Python library, the server retrieves new library information from the Python Package Index (PyPI), and the terminal updates the dependency structure based on that information. The AI model detects incompatible function calls and generates amendments to replace them. The terminal executes the proposal, and the user checks the results with automated tests.

[0282] An example of a prompt sentence for the generative AI model is "Based on the dependency structure, identify potential defects caused by library updates and provide amendments for them." This system enables users to operate software efficiently and reliably.

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

[0284] Step 1:

[0285] The server connects to the software repository via the network. The purpose is to obtain the latest library information. As input, the API endpoint URL of the repository is used. The server sends an HTTP request and obtains the library version information and dependency metadata in JSON format. This JSON data is analyzed to extract the necessary information. The output is a set of parsed library data.

[0286] Step 2:

[0287] The server stores the obtained library information in the storage device. As input, there is the library data obtained in Step 1. The server saves this in the SQL database and updates the existing information. In particular, when there is new version information, it avoids duplication with the old data and adds it newly. The output is the state of the updated database.

[0288] Step 3:

[0289] The terminal obtains the latest library information from the server's database. The input is the library data set provided by the server. Based on this data, the terminal generates a dependency structure. In this process, the terminal uses a dedicated library such as NetworkX to create a graph between software components. The output is a dependency graph.

[0290] Step 4:

[0291] The terminal analyzes the dependency graph and uses a generated AI model to identify potential problems. The input is the generated dependency graph. The AI model uses an algorithm learned from past data to predict incompatibilities and potential defects. Based on this analysis, specific amendments are generated. The output is a list of potential problems and amendments.

[0292] Step 5:

[0293] The terminal automatically updates the source code based on the suggested modifications from the AI ​​model. The input is the suggested modifications provided by the AI ​​model. The terminal applies the modifications to the codebase and automatically performs necessary library updates and code edits. The output is the updated source code.

[0294] Step 6:

[0295] The user runs automated tests provided by the terminal to verify the reliability of the updated code. The inputs are the updated source code and the test script. The terminal runs the tests and outputs the results. The test results are output as a success or error report.

[0296] Step 7:

[0297] The server collects and analyzes test results before reporting them to the user. The input is test result data from the terminal. The server analyzes this data, aggregates the results, and creates a report. The output is a detailed report of the test results, which the user can review.

[0298] Step 8:

[0299] The user approves the deployment of the code to the production environment based on the test results received from the server. The input is the test result report from the server. After approval, the server automatically deploys the code to the production environment. The output is the successfully deployed system. This entire process allows the system to maintain continuous and stable operation.

[0300] (Application Example 1)

[0301] 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."

[0302] In modern, complex software systems, accurately managing the dependencies of each software component and always maintaining the latest state places a significant burden on operators. Additionally, it is currently difficult to quickly identify and resolve potential problems caused by library updates. Furthermore, real-time monitoring and support for stable operation to efficiently perform these tasks are required.

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

[0304] In this invention, the server includes means for acquiring software library information from an external information area and storing it in an internal information management device, means for analyzing the collected software library information to generate and verify an interdependency graph, means for detecting potential problems and generating required amendments, data analysis means for monitoring the state of the software library in real time and supporting operational stability, and means for notifying updated information via a user interface. As a result, operators can easily manage software dependencies and quickly identify and resolve potential problems.

[0305] A "software component" is an individual program or module that constitutes a system and is a basic unit that provides a specific function or service.

[0306] A "dependency" is a relationship indicating a state in which a certain software component operates depending on other components.

[0307] An "external information area" is a place where information that can be accessed via a network such as the Internet is stored.

[0308] A "software library" is a group of codes that provides a specific function and is a collection of programs that can be reused by developers calling that function.

[0309] A "dependency graph" is a diagram that visually represents the dependencies between software components, clearly illustrating the interrelationships between each element.

[0310] A "malfunction" is a software error or defect that causes unintended behavior or results.

[0311] A "proposal for correction" is a specific instruction for change or improvement proposed to resolve a problem.

[0312] "Real-time monitoring" refers to activities that involve continuously observing data and having the ability to respond immediately, so that the latest status can always be understood.

[0313] "Operational stability" refers to a state in which a system continues to function correctly without unintended shutdowns or errors.

[0314] "Data analysis means" refers to a series of processes or methods for deriving useful insights using collected information.

[0315] To implement this invention, a system consisting of a server and a terminal is used. The server acquires software library information from an external information area and stores it in an internal information management device. The software used is Node.js, which performs real-time data processing. The data is exchanged in JSON format and managed using MongoDB. The server utilizes a generative AI model built using TensorFlow to detect potential defects and generate proposed fixes.

[0316] The device is developed using React Native and provides the user interface. The device displays a real-time interdependency graph generated by D3.js. Users can monitor the software's state through this graph and apply suggested fixes via the interface as needed. Furthermore, the device runs automated tests and sends the results to the server.

[0317] As a concrete example, suppose a data center operator manages the system's library status using a terminal. When the system updates a specified library, the AI ​​automatically predicts potential problems and provides appropriate solutions. This ensures the system remains stable. Furthermore, by inputting a prompt such as, "The system may have become unstable after installing the latest library. Please identify dependency issues and suggest solutions," the AI ​​model can provide rapid assistance.

[0318] This allows users to achieve efficient operation and manage library dependencies.

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

[0320] Step 1:

[0321] The server accesses an external information area to retrieve software library information. The input is a list of URLs for the external information area, and data is retrieved using a REST API. The output is library version information and dependency metadata. The retrieved data is in JSON format and is stored in MongoDB, the internal information management system.

[0322] Step 2:

[0323] The server analyzes the collected library information and generates an interdependency graph. The input is library information stored in MongoDB. The output is graph data that visualizes the dependencies between libraries. This process uses a Python library, and the graph is drawn using D3.js.

[0324] Step 3:

[0325] The terminal displays an interdependency graph generated through the user interface. When the user detects an anomaly, they can investigate it on the screen. The input is graph data sent from the server, and the output is a visualized graph on the user interface.

[0326] Step 4:

[0327] The server uses a generative AI model to detect potential bugs and generate suggested fixes. The input consists of a generated dependency graph and change history data. The output is a list of identified bugs and their corresponding suggested fixes. This process utilizes TensorFlow for AI-driven bug detection.

[0328] Step 5:

[0329] The terminal receives AI-generated correction suggestions and presents them on the user interface. The user can review the suggested corrections and apply them as needed. The input is the correction suggestions sent from the server, and the output is the state in which the correction suggestions are presented to the user.

[0330] Step 6:

[0331] The terminal runs automated tests and sends the results to the server. The input is the modified software code based on the applied fixes. The output is log data of the test results. The tests are performed quickly using CI / CD tools.

[0332] Step 7:

[0333] The server analyzes the test results and reports the verification results to the user. The input is log data of the test results sent from the terminal. The output is the analyzed verification results and their report. The results are displayed through the user interface, allowing the user to make a final confirmation.

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

[0335] This invention combines a system that automatically manages the dependencies of software components with an emotion engine that recognizes user emotions. This program processes as follows:

[0336] First, the server retrieves library information from an external data area via the internet. This information is stored in an internal database, where library versions and dependencies are managed. This allows the server to maintain the latest library information in real time and make it available to users.

[0337] The terminal generates a dependency graph using library information stored on the server and analyzes it. This graph is used to visualize the interrelationships between each library and to clearly show the dependencies between software components. If a potential bug is detected, the AI ​​model generates a suggested fix. At this stage, the terminal automatically updates the source code to fix the bug and avoid the problem.

[0338] In this process, users utilize the functions of the emotion engine. The emotion engine analyzes the user's emotions and combines this emotional information to adjust the interface when reporting bugs or suggesting fixes. As a result, it reduces user stress and provides a mechanism that allows users to operate the system more comfortably.

[0339] For example, if a user expresses dissatisfaction with a bug after a library update, the sentiment engine works to alleviate that dissatisfaction by providing a more detailed explanation of the proposed fix or prioritizing the provision of relevant information. Similarly, if a user feels unsure about operating the system, the sentiment engine provides guidance to improve the user experience.

[0340] Finally, the server analyzes the test results and reports the final verification findings to the user. This report includes feedback from the emotion engine and suggests solutions for any areas that need improvement. This ensures that the system is always operating optimally and meeting user needs.

[0341] The following describes the processing flow.

[0342] Step 1:

[0343] The server accesses an external data area and retrieves the latest library information via the internet. This information includes library version information and dependency metadata, which is stored in an internal database. The server keeps this database up-to-date to prepare for subsequent processing.

[0344] Step 2:

[0345] The terminal uses library information provided by the server to generate a dependency graph between software components within the system. The terminal analyzes this graph to understand in detail which components depend on which other libraries.

[0346] Step 3:

[0347] The device uses an AI model to analyze the generated dependency graph and detect potential bugs. This AI model refers to historical data to predict the likelihood of bugs caused by library updates.

[0348] Step 4:

[0349] The emotion engine analyzes the user's emotions in real time. When a user shows an emotional response to the system, the device receives feedback from the emotion engine and adjusts the priority of reports and how details are presented.

[0350] Step 5:

[0351] The device generates suggested fixes for bugs identified by the AI ​​model. Based on these, the device automatically updates the source code to comply with the new library specifications. This update process is carried out appropriately, taking into account the user's sentiment information.

[0352] Step 6:

[0353] The user runs tests to verify the validity of the code updates performed by the device. The user receives feedback from the sentiment engine and can adjust the interface as needed.

[0354] Step 7:

[0355] The server aggregates and analyzes the test results to confirm whether the bugs have been resolved. Along with the analysis results, the server provides the user with a report that includes feedback obtained from user sentiment data.

[0356] Step 8:

[0357] Once user approval is received, the server deploys the updated source code to the production environment and resumes normal system operation. During this process, it is also possible to continuously suggest improvements based on the user's emotional state.

[0358] (Example 2)

[0359] 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".

[0360] In software development, there is a growing need to automatically manage the increasingly complex dependencies between software components and to quickly detect and correct potential problems. Furthermore, optimizing the interface while considering the emotions of system users is also crucial. This invention aims to provide a system that effectively solves these problems.

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

[0362] In this invention, the server includes means for acquiring software component information from an external information area and storing it in an internal information recording device, means for analyzing the collected software component information and generating and comparing dependency diagrams, and means for analyzing user emotions and adaptively adjusting the interface. This makes it possible to efficiently manage software component dependencies, improve the user experience, and quickly identify and correct potential problems.

[0363] The "external information domain" is a source of information for collecting component information that can be accessed via a global information network.

[0364] "Software component information" refers to data containing information about the components of software, including version and dependency information.

[0365] An "internal information recording device" is a database or storage device used to store and manage software component information.

[0366] A "dependency diagram" is a diagram used to visualize the interrelationships between software components, and is a graph that shows the dependencies between them.

[0367] An "interface" is a point of contact for information exchange between a user and a system.

[0368] "Analyzing emotions" refers to the process of evaluating a user's emotional state from data and making decisions based on that information.

[0369] "Adaptively adjusting" means changing the behavior of an interface or system according to the situation or requirements.

[0370] "Rapidly identifying and fixing problems" refers to quickly detecting potential defects or issues and making appropriate corrections.

[0371] This invention provides a system that efficiently manages the dependencies of software components and offers an interface that responds to user emotions. This system operates based on the interaction between the server, terminal, and user.

[0372] The server retrieves software component information from an external information area via the internet. In this process, the server uses a REST API to collect publicly available component information. The collected information is received in JSON format and stored in a database. This database is used to manage library version information and dependencies.

[0373] The terminal generates a dependency diagram using this software component information stored on the server. The terminal uses graph database software (e.g., Neo4j) to create nodes for each software component and edges indicating their dependencies. This information is then plotted as a graph using a visualization tool (e.g., D3.js).

[0374] Users receive support through an emotion engine during this process. The emotion engine has the ability to analyze emotions from the user's input and system operation history. If a user shows frustration while using the system, for example, the emotion engine will adjust the interface and work to reduce stress. This allows users to use the system comfortably.

[0375] A concrete example is a case where a user encounters a bug after a library update and expresses dissatisfaction. In this case, the emotion engine provides a detailed explanation of the proposed bug fix and prioritizes the provision of relevant information. Furthermore, because this system utilizes a generative AI model, it has the ability to propose appropriate solutions tailored to the user's requests.

[0376] A concrete example of a prompt message would be, "Please tell me how to retrieve the latest component information, analyze the dependency diagram, and generate suggested fixes for the detected defects." This allows the system to respond quickly to user requests and provide the optimal solution.

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

[0378] Step 1:

[0379] The server retrieves software component information from an external information area. In this step, it receives the URL and authentication information of an external API as input and obtains a dataset of software components in JSON format as output. Specifically, the server communicates over the network via a REST API, retrieves library information from the specified repository, and writes it to the database.

[0380] Step 2:

[0381] The terminal generates a dependency diagram based on software component information obtained from the server. The input is software component information obtained from a database, and the output is graph data showing the dependencies. In this process, nodes and edges are generated in a graph database (e.g., Neo4j) to visually structure the relationships between components.

[0382] Step 3:

[0383] The terminal analyzes the generated dependency diagram to detect potential problems. The input is the data from the dependency graph, and the output is a list of problems and their details. In this step, machine learning algorithms are used to scan the graph and compare it with existing data models to identify inconsistencies and potential bugs.

[0384] Step 4:

[0385] The AI ​​model generates suggested solutions based on the detected problems. The input is a list of problems, and the output is specific suggested solutions. The generating AI model utilizes natural language processing techniques to propose the optimal solution, referencing past correction history and solutions to similar problems.

[0386] Step 5:

[0387] The device automatically updates the source code based on the proposed modifications generated by the AI ​​model. The input is the proposed modifications, and the output is the updated source code. This process applies the suggested changes to the existing code, ensuring code consistency and accuracy.

[0388] Step 6:

[0389] The server performs tests on the updated source code. The input is the updated source code, and the output is the test results. At this stage, unit tests and integration tests are performed through the CI / CD pipeline to confirm that the update functions as expected.

[0390] Step 7:

[0391] The server analyzes the test results and reports the final verification results to the user. The input is test result data, and the output is a verification report. Specifically, it aggregates the test results, generates a report including the cause and countermeasures if there are any problems, and notifies the user.

[0392] Step 8:

[0393] The user adjusts the system interface using an emotion engine. The input is the user's emotional data, and the output is the adjusted interface settings. The emotion engine analyzes the user's emotional state and adjusts the tone and amount of information in the interface as needed to optimize the user experience.

[0394] (Application Example 2)

[0395] 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."

[0396] In modern software development, managing component dependencies is complex and often leads to potential bugs. Furthermore, users frequently experience stress and anxiety during operation, in addition to these technical issues, which acts as a barrier to software use. Therefore, there is a need for technologies that simultaneously achieve effective dependency management and improved user experience.

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

[0398] In this invention, the server includes means for acquiring library information from an external information storage area and storing it in an internal information storage area; means for analyzing the collected library information and generating and comparing dependency graphs; means for detecting potential defects and generating necessary corrective measures; and means for analyzing user emotions and dynamically adjusting the interface. This enables efficient dependency management of software and reduces stress on the user while improving the user experience.

[0399] "Software components" refer to individual program parts that make up a program, such as libraries, modules, and frameworks.

[0400] A "dependency" refers to a relationship where one software component depends on another and operates in relation to them.

[0401] An "external information storage area" is a location on the internet or a network where various data and library information are stored.

[0402] "Library information" refers to data that includes version information and dependencies of program components and modules used in software development.

[0403] The "internal information storage area" is a storage area for temporarily or permanently storing data necessary for use within the system.

[0404] A "malfunction" refers to a problem where software does not function correctly or does not produce the expected results.

[0405] A "proposal for correction" refers to a specific plan or proposed change aimed at resolving a detected defect.

[0406] "Program code" refers to a set of instructions written to build software, or text used to give commands to a computer processor.

[0407] "Testing" refers to a specific testing process conducted to verify that software operates according to specifications.

[0408] "User emotions" refers to the emotions and psychological states expressed by users when using software.

[0409] An "interface" is an element that defines the screen display and operability when a user interacts with software.

[0410] "Stress reduction" refers to measures and functions designed to lower the psychological burden that users experience when using software.

[0411] This invention is a system for dynamically adjusting the interface by analyzing user emotions while efficiently managing the dependencies of software components.

[0412] The server retrieves library information from an external information storage area via the information and communication network and stores this data in its internal information storage unit. This information is important because it provides the data necessary for managing dependencies and analyzing defects.

[0413] The terminal analyzes library information obtained from the server, generates a dependency graph, and clearly shows the relationships between each library. This allows for the detection of potential bugs and the generation of suggested fixes as needed. Based on these suggested fixes, the program code is automatically updated, providing users with a highly reliable system.

[0414] Users operate the software through their devices, and during this process, an emotion analysis engine analyzes the user's facial expressions and voice tone to understand their emotions. Based on this emotional information, the interface is dynamically adjusted to improve the user experience. If the user feels stressed, the interface becomes more user-friendly; if they feel anxious, detailed guides and supplementary information are provided to reduce the psychological burden of using the software.

[0415] As a concrete example, if this system is implemented in a smartphone application, when an error occurs while the user is updating a library, the emotion engine can detect from the user's facial expression that they are experiencing stress. In this case, the app automatically displays a detailed explanation of the error and troubleshooting steps to alleviate the user's anxiety. It also provides the user with interactive guidance as needed. At this point, a generative AI model is used to determine the optimal approach based on the user's state.

[0416] An example of a prompt might be: "If the user feels uneasy during payment, suggest ways to display additional information and improve the user experience. How do you analyze the user's emotions and respond?"

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

[0418] Step 1:

[0419] The server retrieves library information from an external information storage area via an information and communication network. The input is library information from the external storage area, and the output is data stored in the internal information storage unit. The data is retrieved in real time and organized to maintain the latest library information.

[0420] Step 2:

[0421] The terminal receives library information provided by the server, analyzes that data, and generates a dependency graph. The input is library information obtained from the server, and the output is the generated dependency graph. The analysis checks the links of each library in the database and models their relationships in a visually understandable way.

[0422] Step 3:

[0423] The device uses the generated dependency graph to detect potential bugs and generate suggested fixes. The input is the dependency graph, and the output is the bugs and their suggested fixes. Here, a generative AI model is used to analyze bug patterns and calculate the optimal fix procedure.

[0424] Step 4:

[0425] The terminal automatically updates the program code based on the generated correction proposal. The input is the correction proposal, and the output is the updated program code. The system directly modifies the code and records the changes that are reflected.

[0426] Step 5:

[0427] The terminal performs tests to determine the validity of the updated code. The input is the updated program code, and the output is the test result. The tests verify operation in specific scenarios and collect data to confirm normal operation.

[0428] Step 6:

[0429] The server analyzes the test results and reports the findings to the user. The input is the test results, and the output is the report to the user. Using an emotion engine, the report is tailored to the user's situation and presented in text and graphics.

[0430] Step 7:

[0431] While the user operates the system through their device, their emotions are analyzed by an emotion analysis engine. The input is the user's facial expressions and voice during operation, and the output is the analyzed emotion data. Based on the emotion data, the interface is adjusted, and necessary guides and information are displayed.

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

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

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

[0435] [Third Embodiment]

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

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

[0438] 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).

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

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

[0441] 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).

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

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

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

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

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

[0447] 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".

[0448] The present invention is a system for automatically managing the dependencies of software components, and its program processes as follows.

[0449] First, the server retrieves library information from an external data area accessible via the internet. This includes metadata such as library version information and dependency information. The server organizes and stores the retrieved information in an internal database to maintain up-to-date information.

[0450] Next, the terminal generates a dependency graph using library information stored on the server. This allows for the visualization and analysis of the interdependencies between each software component. The terminal analyzes this dependency graph and uses an AI model to detect potential bugs.

[0451] The AI ​​model identifies potential bugs caused by library updates and generates necessary fixes. Based on these fixes, the device automatically updates its source code to conform to the latest library specifications. This ensures that the system continues to operate stably.

[0452] The user runs tests to validate the modified code. The terminal automates this testing process and aggregates the test results to the server. The server analyzes the test results to confirm whether the bug has been resolved.

[0453] Finally, the server reports the test results and fixes to the user. If the user approves based on this report, the server deploys the updated code to the production environment and resumes normal system operation.

[0454] These processes ensure that the latest state of libraries is always maintained, preventing system instability caused by dependencies. This invention frees users from the complex manual tasks associated with library updates, enabling more efficient and reliable system operation.

[0455] The following describes the processing flow.

[0456] Step 1:

[0457] The server periodically accesses an external data area to retrieve the latest library information. This information includes metadata about library versions, release notes, and dependencies. The server stores this data in an internal database and organizes the information for easy access by administrators.

[0458] Step 2:

[0459] The terminal uses library information obtained from the server to generate a dependency graph between the installed software components. This visualizes the interdependencies between libraries and each component within the system, allowing for the identification of potential problems.

[0460] Step 3:

[0461] The device inputs the generated dependency graph into the AI ​​model to detect potential bugs associated with library updates. The AI ​​model predicts problems based on past data and evaluates the likelihood of specific bugs.

[0462] Step 4:

[0463] The device generates suggested fixes for bugs identified by the AI ​​model. Based on these suggested fixes, the device automatically updates the source code to conform to the new library specifications. The code modifications are performed according to the optimal method recommended by the AI ​​model.

[0464] Step 5:

[0465] The user runs automatically generated tests to verify the validity of the code updated by the device. The device monitors the test execution and records the results. This testing process ensures that the modified code functions as intended.

[0466] Step 6:

[0467] The server aggregates the test results, analyzes them, and checks the status of resolving possible bugs. The server reports the analysis results to the user as detailed feedback and suggests further actions.

[0468] Step 7:

[0469] Once user approval is received, the server deploys the updated code to the production environment. This resumes system operation based on the latest library specifications, ensuring system stability and efficiency.

[0470] (Example 1)

[0471] 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."

[0472] In existing software development, the increasing complexity of dependencies between software components makes manual management extremely difficult due to library updates and changes in dependencies. This increases the risk of system instability and defects, resulting in decreased development efficiency and reliability. Furthermore, the lack of means to identify potential defects in advance means that countermeasures cannot be taken until problems become apparent.

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

[0474] In this invention, the server includes means for acquiring software information from an information area and storing it in a storage device, means for analyzing the collected software information and generating and checking dependency structures, and means for detecting potential problems and generating optimal solutions using a machine learning model. This makes it possible to keep the dependencies of software components up-to-date and optimal at all times, and the automated system enables proactive prevention of defects and expedited resolution.

[0475] "Information area" refers to an external or internal storage device that holds software information, including repositories accessible via a network.

[0476] "Software information" refers to data about software components, including version information and dependency metadata.

[0477] "Storage device" refers to an internal database or storage medium used to store collected information.

[0478] A "dependency structure" is a data structure that shows the interrelationships between multiple software elements, and includes graph formats.

[0479] A "machine learning model" refers to an algorithm or system that learns from past data and uses it to make predictions and analyses in new situations.

[0480] "Potential problems" refer to elements in the software that may have incompatibilities or defects, and it is desirable to detect them in advance.

[0481] A "proposal for correction" refers to a specific method or proposed change to resolve the detected problem, and is used as part of the automated update process.

[0482] This invention operates as a system that automatically manages the dependencies of software components. The entire system mainly consists of a server, terminals, and users.

[0483] The server retrieves the latest software information from software repositories accessible via the internet. This information includes version information and dependency metadata. The server stores the retrieved information in its internal storage and manages and updates it using a database. Specifically, SQL databases or NoSQL storage may be used.

[0484] The terminal uses software information stored on the server to form a dependency structure. This dependency structure is implemented as a graph representing the interrelationships between software components. The terminal generates this graph using a graph library such as NetworkX and then analyzes it.

[0485] Furthermore, the device uses a generative AI model to detect potential problems. This AI model is based on machine learning algorithms and uses the trained data to determine the risk of incompatibilities and defects caused by software updates. The AI ​​model generates suggested fixes for predicted problems and automatically updates the code based on those fixes.

[0486] Users verify the validity of updated code through automated tests run on their devices. Continuous integration (CI) tools are used for testing, and test results are centrally managed on the server. This allows for rapid evaluation of whether issues have been resolved and reports are provided to the user.

[0487] For example, if a project uses a Python library, the server retrieves new library information from the Python Package Index (PyPI), and the terminal updates the dependency structure based on that information. The AI ​​model detects incompatible function calls and generates alternative solutions. The terminal executes these suggestions, and the user verifies the results with automated tests.

[0488] An example of a prompt for the generated AI model is, "Based on the dependency structure, identify potential bugs that may arise from library updates and provide proposed fixes." This system enables users to operate software efficiently and reliably.

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

[0490] Step 1:

[0491] The server connects to the software repository via the network. Its purpose is to retrieve the latest library information. The repository's API endpoint URL is used as input. The server sends an HTTP request and retrieves library version information and dependency metadata in JSON format. This JSON data is then parsed, and the necessary information is extracted. The output is a set of the parsed library data.

[0492] Step 2:

[0493] The server stores the retrieved library information in storage. The input is the library data retrieved in step 1. The server saves this to an SQL database and updates the existing information. In particular, if there is new version information, it avoids duplication with old data and adds the new information. The output is the updated state of the database.

[0494] Step 3:

[0495] The terminal retrieves the latest library information from the server's database. The input is the library dataset provided by the server. Based on this data, the terminal generates a dependency structure. In this process, the terminal uses a dedicated library such as NetworkX to create a graph of the relationships between software components. The output is the dependency graph.

[0496] Step 4:

[0497] The device analyzes the dependency graph and identifies potential problems using a generative AI model. The input is the generated dependency graph. The AI ​​model uses algorithms learned from historical data to predict incompatibilities and potential bugs. This analysis generates specific corrective action plans. The output is a list of potential problems and their corresponding solutions.

[0498] Step 5:

[0499] The terminal automatically updates the source code based on the suggested modifications from the AI ​​model. The input is the suggested modifications provided by the AI ​​model. The terminal applies the modifications to the codebase and automatically performs necessary library updates and code edits. The output is the updated source code.

[0500] Step 6:

[0501] The user runs automated tests provided by the terminal to verify the reliability of the updated code. The inputs are the updated source code and the test script. The terminal runs the tests and outputs the results. The test results are output as a success or error report.

[0502] Step 7:

[0503] The server collects and analyzes test results before reporting them to the user. The input is test result data from the terminal. The server analyzes this data, aggregates the results, and creates a report. The output is a detailed report of the test results, which the user can review.

[0504] Step 8:

[0505] The user approves the deployment of the code to the production environment based on the test results received from the server. The input is the test result report from the server. After approval, the server automatically deploys the code to the production environment. The output is the successfully deployed system. This entire process allows the system to maintain continuous and stable operation.

[0506] (Application Example 1)

[0507] 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."

[0508] In today's complex software systems, accurately managing the dependencies between software components and keeping them constantly up-to-date is a significant burden for operators. Furthermore, quickly identifying and resolving potential bugs arising from library updates is also challenging. Moreover, real-time monitoring and support for stable operation are needed to efficiently perform these tasks.

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

[0510] In this invention, the server includes means for acquiring software library information from an external information area and storing it in an internal information management device; means for analyzing the collected software library information and generating and comparing interdependency graphs; means for detecting potential defects and generating necessary corrective measures; means for monitoring the status of software libraries in real time and supporting operational stability through data analysis; and means for notifying update information via a user interface. This enables operators to easily manage software dependencies and quickly identify and resolve potential defects.

[0511] "Software components" are individual programs or modules that make up a system, and are fundamental units that provide specific functions or services.

[0512] A "dependency" is a relationship that describes a state in which one software component operates in relation to another element.

[0513] The "external information area" is a location where information that can be accessed via a network such as the internet is stored.

[0514] A "software library" is a collection of code that provides specific functionality, and it is a set of programs that can be reused by developers by calling that functionality.

[0515] A "dependency graph" is a diagram that visually represents the dependencies between software components, clearly illustrating the interrelationships between each element.

[0516] A "malfunction" is a software error or defect that causes unintended behavior or results.

[0517] A "proposal for correction" is a specific instruction for change or improvement proposed to resolve a problem.

[0518] "Real-time monitoring" refers to activities that involve continuously observing data and having the ability to respond immediately, so that the latest status can always be understood.

[0519] "Operational stability" refers to a state in which a system continues to function correctly without unintended shutdowns or errors.

[0520] "Data analysis means" refers to a series of processes or methods for deriving useful insights using collected information.

[0521] To implement this invention, a system consisting of a server and a terminal is used. The server acquires software library information from an external information area and stores it in an internal information management device. The software used is Node.js, which performs real-time data processing. The data is exchanged in JSON format and managed using MongoDB. The server utilizes a generative AI model built using TensorFlow to detect potential defects and generate proposed fixes.

[0522] The device is developed using React Native and provides the user interface. The device displays a real-time interdependency graph generated by D3.js. Users can monitor the software's state through this graph and apply suggested fixes via the interface as needed. Furthermore, the device runs automated tests and sends the results to the server.

[0523] As a concrete example, suppose a data center operator manages the system's library status using a terminal. When the system updates a specified library, the AI ​​automatically predicts potential problems and provides appropriate solutions. This ensures the system remains stable. Furthermore, by inputting a prompt such as, "The system may have become unstable after installing the latest library. Please identify dependency issues and suggest solutions," the AI ​​model can provide rapid assistance.

[0524] This allows users to achieve efficient operation and manage library dependencies.

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

[0526] Step 1:

[0527] The server accesses an external information area to retrieve software library information. The input is a list of URLs for the external information area, and data is retrieved using a REST API. The output is library version information and dependency metadata. The retrieved data is in JSON format and is stored in MongoDB, the internal information management system.

[0528] Step 2:

[0529] The server analyzes the collected library information and generates an interdependency graph. The input is library information stored in MongoDB. The output is graph data that visualizes the dependencies between libraries. This process uses a Python library, and the graph is drawn using D3.js.

[0530] Step 3:

[0531] The terminal displays an interdependency graph generated through the user interface. When the user detects an anomaly, they can investigate it on the screen. The input is graph data sent from the server, and the output is a visualized graph on the user interface.

[0532] Step 4:

[0533] The server uses a generative AI model to detect potential bugs and generate suggested fixes. The input consists of a generated dependency graph and change history data. The output is a list of identified bugs and their corresponding suggested fixes. This process utilizes TensorFlow for AI-driven bug detection.

[0534] Step 5:

[0535] The terminal receives AI-generated correction suggestions and presents them on the user interface. The user can review the suggested corrections and apply them as needed. The input is the correction suggestions sent from the server, and the output is the state in which the correction suggestions are presented to the user.

[0536] Step 6:

[0537] The terminal runs automated tests and sends the results to the server. The input is the modified software code based on the applied fixes. The output is log data of the test results. The tests are performed quickly using CI / CD tools.

[0538] Step 7:

[0539] The server analyzes the test results and reports the verification results to the user. The input is log data of the test results sent from the terminal. The output is the analyzed verification results and their report. The results are displayed through the user interface, allowing the user to make a final confirmation.

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

[0541] This invention combines a system that automatically manages the dependencies of software components with an emotion engine that recognizes user emotions. This program processes as follows:

[0542] First, the server retrieves library information from an external data area via the internet. This information is stored in an internal database, where library versions and dependencies are managed. This allows the server to maintain the latest library information in real time and make it available to users.

[0543] The terminal generates a dependency graph using library information stored on the server and analyzes it. This graph is used to visualize the interrelationships between each library and to clearly show the dependencies between software components. If a potential bug is detected, the AI ​​model generates a suggested fix. At this stage, the terminal automatically updates the source code to fix the bug and avoid the problem.

[0544] In this process, users utilize the functions of the emotion engine. The emotion engine analyzes the user's emotions and combines this emotional information to adjust the interface when reporting bugs or suggesting fixes. As a result, it reduces user stress and provides a mechanism that allows users to operate the system more comfortably.

[0545] For example, if a user expresses dissatisfaction with a bug after a library update, the sentiment engine works to alleviate that dissatisfaction by providing a more detailed explanation of the proposed fix or prioritizing the provision of relevant information. Similarly, if a user feels unsure about operating the system, the sentiment engine provides guidance to improve the user experience.

[0546] Finally, the server analyzes the test results and reports the final verification findings to the user. This report includes feedback from the emotion engine and suggests solutions for any areas that need improvement. This ensures that the system is always operating optimally and meeting user needs.

[0547] The following describes the processing flow.

[0548] Step 1:

[0549] The server accesses an external data area and retrieves the latest library information via the internet. This information includes library version information and dependency metadata, which is stored in an internal database. The server keeps this database up-to-date to prepare for subsequent processing.

[0550] Step 2:

[0551] The terminal uses library information provided by the server to generate a dependency graph between software components within the system. The terminal analyzes this graph to understand in detail which components depend on which other libraries.

[0552] Step 3:

[0553] The device uses an AI model to analyze the generated dependency graph and detect potential bugs. This AI model refers to historical data to predict the likelihood of bugs caused by library updates.

[0554] Step 4:

[0555] The emotion engine analyzes the user's emotions in real time. When a user shows an emotional response to the system, the device receives feedback from the emotion engine and adjusts the priority of reports and how details are presented.

[0556] Step 5:

[0557] The device generates suggested fixes for bugs identified by the AI ​​model. Based on these, the device automatically updates the source code to comply with the new library specifications. This update process is carried out appropriately, taking into account the user's sentiment information.

[0558] Step 6:

[0559] The user runs tests to verify the validity of the code updates performed by the device. The user receives feedback from the sentiment engine and can adjust the interface as needed.

[0560] Step 7:

[0561] The server aggregates and analyzes the test results to confirm whether the bugs have been resolved. Along with the analysis results, the server provides the user with a report that includes feedback obtained from user sentiment data.

[0562] Step 8:

[0563] Once user approval is received, the server deploys the updated source code to the production environment and resumes normal system operation. During this process, it is also possible to continuously suggest improvements based on the user's emotional state.

[0564] (Example 2)

[0565] 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."

[0566] In software development, there is a growing need to automatically manage the increasingly complex dependencies between software components and to quickly detect and correct potential problems. Furthermore, optimizing the interface while considering the emotions of system users is also crucial. This invention aims to provide a system that effectively solves these problems.

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

[0568] In this invention, the server includes means for acquiring software component information from an external information area and storing it in an internal information recording device, means for analyzing the collected software component information and generating and comparing dependency diagrams, and means for analyzing user emotions and adaptively adjusting the interface. This makes it possible to efficiently manage software component dependencies, improve the user experience, and quickly identify and correct potential problems.

[0569] The "external information domain" is a source of information for collecting component information that can be accessed via a global information network.

[0570] "Software component information" refers to data containing information about the components of software, including version and dependency information.

[0571] An "internal information recording device" is a database or storage device used to store and manage software component information.

[0572] A "dependency diagram" is a diagram used to visualize the interrelationships between software components, and is a graph that shows the dependencies between them.

[0573] An "interface" is a point of contact for information exchange between a user and a system.

[0574] "Analyzing emotions" refers to the process of evaluating a user's emotional state from data and making decisions based on that information.

[0575] "Adaptively adjusting" means changing the behavior of an interface or system according to the situation or requirements.

[0576] "Rapidly identifying and fixing problems" refers to quickly detecting potential defects or issues and making appropriate corrections.

[0577] This invention provides a system that efficiently manages the dependencies of software components and offers an interface that responds to user emotions. This system operates based on the interaction between the server, terminal, and user.

[0578] The server retrieves software component information from an external information area via the internet. In this process, the server uses a REST API to collect publicly available component information. The collected information is received in JSON format and stored in a database. This database is used to manage library version information and dependencies.

[0579] The terminal generates a dependency diagram using this software component information stored on the server. The terminal uses graph database software (e.g., Neo4j) to create nodes for each software component and edges indicating their dependencies. This information is then plotted as a graph using a visualization tool (e.g., D3.js).

[0580] Users receive support through an emotion engine during this process. The emotion engine has the ability to analyze emotions from the user's input and system operation history. If a user shows frustration while using the system, for example, the emotion engine will adjust the interface and work to reduce stress. This allows users to use the system comfortably.

[0581] A concrete example is a case where a user encounters a bug after a library update and expresses dissatisfaction. In this case, the emotion engine provides a detailed explanation of the proposed bug fix and prioritizes the provision of relevant information. Furthermore, because this system utilizes a generative AI model, it has the ability to propose appropriate solutions tailored to the user's requests.

[0582] A concrete example of a prompt message would be, "Please tell me how to retrieve the latest component information, analyze the dependency diagram, and generate suggested fixes for the detected defects." This allows the system to respond quickly to user requests and provide the optimal solution.

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

[0584] Step 1:

[0585] The server retrieves software component information from an external information area. In this step, it receives the URL and authentication information of an external API as input and obtains a dataset of software components in JSON format as output. Specifically, the server communicates over the network via a REST API, retrieves library information from the specified repository, and writes it to the database.

[0586] Step 2:

[0587] The terminal generates a dependency diagram based on software component information obtained from the server. The input is software component information obtained from a database, and the output is graph data showing the dependencies. In this process, nodes and edges are generated in a graph database (e.g., Neo4j) to visually structure the relationships between components.

[0588] Step 3:

[0589] The terminal analyzes the generated dependency diagram to detect potential problems. The input is the data from the dependency graph, and the output is a list of problems and their details. In this step, machine learning algorithms are used to scan the graph and compare it with existing data models to identify inconsistencies and potential bugs.

[0590] Step 4:

[0591] The AI ​​model generates suggested solutions based on the detected problems. The input is a list of problems, and the output is specific suggested solutions. The generating AI model utilizes natural language processing techniques to propose the optimal solution, referencing past correction history and solutions to similar problems.

[0592] Step 5:

[0593] The device automatically updates the source code based on the proposed modifications generated by the AI ​​model. The input is the proposed modifications, and the output is the updated source code. This process applies the suggested changes to the existing code, ensuring code consistency and accuracy.

[0594] Step 6:

[0595] The server performs tests on the updated source code. The input is the updated source code, and the output is the test results. At this stage, unit tests and integration tests are performed through the CI / CD pipeline to confirm that the update functions as expected.

[0596] Step 7:

[0597] The server analyzes the test results and reports the final verification results to the user. The input is test result data, and the output is a verification report. Specifically, it aggregates the test results, generates a report including the cause and countermeasures if there are any problems, and notifies the user.

[0598] Step 8:

[0599] The user adjusts the system interface using an emotion engine. The input is the user's emotional data, and the output is the adjusted interface settings. The emotion engine analyzes the user's emotional state and adjusts the tone and amount of information in the interface as needed to optimize the user experience.

[0600] (Application Example 2)

[0601] 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."

[0602] In modern software development, managing component dependencies is complex and often leads to potential bugs. Furthermore, users frequently experience stress and anxiety during operation, in addition to these technical issues, which acts as a barrier to software use. Therefore, there is a need for technologies that simultaneously achieve effective dependency management and improved user experience.

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

[0604] In this invention, the server includes means for acquiring library information from an external information storage area and storing it in an internal information storage area; means for analyzing the collected library information and generating and comparing dependency graphs; means for detecting potential defects and generating necessary corrective measures; and means for analyzing user emotions and dynamically adjusting the interface. This enables efficient dependency management of software and reduces stress on the user while improving the user experience.

[0605] "Software components" refer to individual program parts that make up a program, such as libraries, modules, and frameworks.

[0606] A "dependency" refers to a relationship where one software component depends on another and operates in relation to them.

[0607] An "external information storage area" is a location on the internet or a network where various data and library information are stored.

[0608] "Library information" refers to data that includes version information and dependencies of program components and modules used in software development.

[0609] The "internal information storage area" is a storage area for temporarily or permanently storing data necessary for use within the system.

[0610] A "malfunction" refers to a problem where software does not function correctly or does not produce the expected results.

[0611] A "proposal for correction" refers to a specific plan or proposed change aimed at resolving a detected defect.

[0612] "Program code" refers to a set of instructions written to build software, or text used to give commands to a computer processor.

[0613] "Testing" refers to a specific testing process conducted to verify that software operates according to specifications.

[0614] "User emotions" refers to the emotions and psychological states expressed by users when using software.

[0615] An "interface" is an element that defines the screen display and operability when a user interacts with software.

[0616] "Stress reduction" refers to measures and functions designed to lower the psychological burden that users experience when using software.

[0617] This invention is a system for dynamically adjusting the interface by analyzing user emotions while efficiently managing the dependencies of software components.

[0618] The server retrieves library information from an external information storage area via the information and communication network and stores this data in its internal information storage unit. This information is important because it provides the data necessary for managing dependencies and analyzing defects.

[0619] The terminal analyzes library information obtained from the server, generates a dependency graph, and clearly shows the relationships between each library. This allows for the detection of potential bugs and the generation of suggested fixes as needed. Based on these suggested fixes, the program code is automatically updated, providing users with a highly reliable system.

[0620] Users operate the software through their devices, and during this process, an emotion analysis engine analyzes the user's facial expressions and voice tone to understand their emotions. Based on this emotional information, the interface is dynamically adjusted to improve the user experience. If the user feels stressed, the interface becomes more user-friendly; if they feel anxious, detailed guides and supplementary information are provided to reduce the psychological burden of using the software.

[0621] As a concrete example, if this system is implemented in a smartphone application, when an error occurs while the user is updating a library, the emotion engine can detect from the user's facial expression that they are experiencing stress. In this case, the app automatically displays a detailed explanation of the error and troubleshooting steps to alleviate the user's anxiety. It also provides the user with interactive guidance as needed. At this point, a generative AI model is used to determine the optimal approach based on the user's state.

[0622] An example of a prompt might be: "If the user feels uneasy during payment, suggest ways to display additional information and improve the user experience. How do you analyze the user's emotions and respond?"

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

[0624] Step 1:

[0625] The server retrieves library information from an external information storage area via an information and communication network. The input is library information from the external storage area, and the output is data stored in the internal information storage unit. The data is retrieved in real time and organized to maintain the latest library information.

[0626] Step 2:

[0627] The terminal receives library information provided by the server, analyzes that data, and generates a dependency graph. The input is library information obtained from the server, and the output is the generated dependency graph. The analysis checks the links of each library in the database and models their relationships in a visually understandable way.

[0628] Step 3:

[0629] The device uses the generated dependency graph to detect potential bugs and generate suggested fixes. The input is the dependency graph, and the output is the bugs and their suggested fixes. Here, a generative AI model is used to analyze bug patterns and calculate the optimal fix procedure.

[0630] Step 4:

[0631] The terminal automatically updates the program code based on the generated correction proposal. The input is the correction proposal, and the output is the updated program code. The system directly modifies the code and records the changes that are reflected.

[0632] Step 5:

[0633] The terminal performs tests to determine the validity of the updated code. The input is the updated program code, and the output is the test result. The tests verify operation in specific scenarios and collect data to confirm normal operation.

[0634] Step 6:

[0635] The server analyzes the test results and reports the findings to the user. The input is the test results, and the output is the report to the user. Using an emotion engine, the report is tailored to the user's situation and presented in text and graphics.

[0636] Step 7:

[0637] While the user operates the system through their device, their emotions are analyzed by an emotion analysis engine. The input is the user's facial expressions and voice during operation, and the output is the analyzed emotion data. Based on the emotion data, the interface is adjusted, and necessary guides and information are displayed.

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

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

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

[0641] [Fourth Embodiment]

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

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

[0644] 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).

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

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

[0647] 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).

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

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

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

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

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

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

[0654] 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".

[0655] The present invention is a system for automatically managing the dependencies of software components, and its program processes as follows.

[0656] First, the server retrieves library information from an external data area accessible via the internet. This includes metadata such as library version information and dependency information. The server organizes and stores the retrieved information in an internal database to maintain up-to-date information.

[0657] Next, the terminal generates a dependency graph using library information stored on the server. This allows for the visualization and analysis of the interdependencies between each software component. The terminal analyzes this dependency graph and uses an AI model to detect potential bugs.

[0658] The AI ​​model identifies potential bugs caused by library updates and generates necessary fixes. Based on these fixes, the device automatically updates its source code to conform to the latest library specifications. This ensures that the system continues to operate stably.

[0659] The user runs tests to validate the modified code. The terminal automates this testing process and aggregates the test results to the server. The server analyzes the test results to confirm whether the bug has been resolved.

[0660] Finally, the server reports the test results and fixes to the user. If the user approves based on this report, the server deploys the updated code to the production environment and resumes normal system operation.

[0661] These processes ensure that the latest state of libraries is always maintained, preventing system instability caused by dependencies. This invention frees users from the complex manual tasks associated with library updates, enabling more efficient and reliable system operation.

[0662] The following describes the processing flow.

[0663] Step 1:

[0664] The server periodically accesses an external data area to retrieve the latest library information. This information includes metadata about library versions, release notes, and dependencies. The server stores this data in an internal database and organizes the information for easy access by administrators.

[0665] Step 2:

[0666] The terminal uses library information obtained from the server to generate a dependency graph between the installed software components. This visualizes the interdependencies between libraries and each component within the system, allowing for the identification of potential problems.

[0667] Step 3:

[0668] The device inputs the generated dependency graph into the AI ​​model to detect potential bugs associated with library updates. The AI ​​model predicts problems based on past data and evaluates the likelihood of specific bugs.

[0669] Step 4:

[0670] The device generates suggested fixes for bugs identified by the AI ​​model. Based on these suggested fixes, the device automatically updates the source code to conform to the new library specifications. The code modifications are performed according to the optimal method recommended by the AI ​​model.

[0671] Step 5:

[0672] The user runs automatically generated tests to verify the validity of the code updated by the device. The device monitors the test execution and records the results. This testing process ensures that the modified code functions as intended.

[0673] Step 6:

[0674] The server aggregates the test results, analyzes them, and checks the status of resolving possible bugs. The server reports the analysis results to the user as detailed feedback and suggests further actions.

[0675] Step 7:

[0676] Once user approval is received, the server deploys the updated code to the production environment. This resumes system operation based on the latest library specifications, ensuring system stability and efficiency.

[0677] (Example 1)

[0678] 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".

[0679] In existing software development, the increasing complexity of dependencies between software components makes manual management extremely difficult due to library updates and changes in dependencies. This increases the risk of system instability and defects, resulting in decreased development efficiency and reliability. Furthermore, the lack of means to identify potential defects in advance means that countermeasures cannot be taken until problems become apparent.

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

[0681] In this invention, the server includes means for acquiring software information from an information area and storing it in a storage device, means for analyzing the collected software information and generating and checking dependency structures, and means for detecting potential problems and generating optimal solutions using a machine learning model. This makes it possible to keep the dependencies of software components up-to-date and optimal at all times, and the automated system enables proactive prevention of defects and expedited resolution.

[0682] "Information area" refers to an external or internal storage device that holds software information, including repositories accessible via a network.

[0683] "Software information" refers to data about software components, including version information and dependency metadata.

[0684] "Storage device" refers to an internal database or storage medium used to store collected information.

[0685] A "dependency structure" is a data structure that shows the interrelationships between multiple software elements, and includes graph formats.

[0686] A "machine learning model" refers to an algorithm or system that learns from past data and uses it to make predictions and analyses in new situations.

[0687] "Potential problems" refer to elements in the software that may have incompatibilities or defects, and it is desirable to detect them in advance.

[0688] A "proposal for correction" refers to a specific method or proposed change to resolve the detected problem, and is used as part of the automated update process.

[0689] This invention operates as a system that automatically manages the dependencies of software components. The entire system mainly consists of a server, terminals, and users.

[0690] The server retrieves the latest software information from software repositories accessible via the internet. This information includes version information and dependency metadata. The server stores the retrieved information in its internal storage and manages and updates it using a database. Specifically, SQL databases or NoSQL storage may be used.

[0691] The terminal uses software information stored on the server to form a dependency structure. This dependency structure is implemented as a graph representing the interrelationships between software components. The terminal generates this graph using a graph library such as NetworkX and then analyzes it.

[0692] Furthermore, the device uses a generative AI model to detect potential problems. This AI model is based on machine learning algorithms and uses the trained data to determine the risk of incompatibilities and defects caused by software updates. The AI ​​model generates suggested fixes for predicted problems and automatically updates the code based on those fixes.

[0693] Users verify the validity of updated code through automated tests run on their devices. Continuous integration (CI) tools are used for testing, and test results are centrally managed on the server. This allows for rapid evaluation of whether issues have been resolved and reports are provided to the user.

[0694] For example, if a project uses a Python library, the server retrieves new library information from the Python Package Index (PyPI), and the terminal updates the dependency structure based on that information. The AI ​​model detects incompatible function calls and generates alternative solutions. The terminal executes these suggestions, and the user verifies the results with automated tests.

[0695] An example of a prompt for the generated AI model is, "Based on the dependency structure, identify potential bugs that may arise from library updates and provide proposed fixes." This system enables users to operate software efficiently and reliably.

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

[0697] Step 1:

[0698] The server connects to the software repository via the network. Its purpose is to retrieve the latest library information. The repository's API endpoint URL is used as input. The server sends an HTTP request and retrieves library version information and dependency metadata in JSON format. This JSON data is then parsed, and the necessary information is extracted. The output is a set of the parsed library data.

[0699] Step 2:

[0700] The server stores the retrieved library information in storage. The input is the library data retrieved in step 1. The server saves this to an SQL database and updates the existing information. In particular, if there is new version information, it avoids duplication with old data and adds the new information. The output is the updated state of the database.

[0701] Step 3:

[0702] The terminal retrieves the latest library information from the server's database. The input is the library dataset provided by the server. Based on this data, the terminal generates a dependency structure. In this process, the terminal uses a dedicated library such as NetworkX to create a graph of the relationships between software components. The output is the dependency graph.

[0703] Step 4:

[0704] The device analyzes the dependency graph and identifies potential problems using a generative AI model. The input is the generated dependency graph. The AI ​​model uses algorithms learned from historical data to predict incompatibilities and potential bugs. This analysis generates specific corrective action plans. The output is a list of potential problems and their corresponding solutions.

[0705] Step 5:

[0706] The terminal automatically updates the source code based on the suggested modifications from the AI ​​model. The input is the suggested modifications provided by the AI ​​model. The terminal applies the modifications to the codebase and automatically performs necessary library updates and code edits. The output is the updated source code.

[0707] Step 6:

[0708] The user runs automated tests provided by the terminal to verify the reliability of the updated code. The inputs are the updated source code and the test script. The terminal runs the tests and outputs the results. The test results are output as a success or error report.

[0709] Step 7:

[0710] The server collects and analyzes test results before reporting them to the user. The input is test result data from the terminal. The server analyzes this data, aggregates the results, and creates a report. The output is a detailed report of the test results, which the user can review.

[0711] Step 8:

[0712] The user approves the deployment of the code to the production environment based on the test results received from the server. The input is the test result report from the server. After approval, the server automatically deploys the code to the production environment. The output is the successfully deployed system. This entire process allows the system to maintain continuous and stable operation.

[0713] (Application Example 1)

[0714] 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".

[0715] In today's complex software systems, accurately managing the dependencies between software components and keeping them constantly up-to-date is a significant burden for operators. Furthermore, quickly identifying and resolving potential bugs arising from library updates is also challenging. Moreover, real-time monitoring and support for stable operation are needed to efficiently perform these tasks.

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

[0717] In this invention, the server includes means for acquiring software library information from an external information area and storing it in an internal information management device; means for analyzing the collected software library information and generating and comparing interdependency graphs; means for detecting potential defects and generating necessary corrective measures; means for monitoring the status of software libraries in real time and supporting operational stability through data analysis; and means for notifying update information via a user interface. This enables operators to easily manage software dependencies and quickly identify and resolve potential defects.

[0718] "Software components" are individual programs or modules that make up a system, and are fundamental units that provide specific functions or services.

[0719] A "dependency" is a relationship that describes a state in which one software component operates in relation to another element.

[0720] The "external information area" is a location where information that can be accessed via a network such as the internet is stored.

[0721] A "software library" is a collection of code that provides specific functionality, and it is a set of programs that can be reused by developers by calling that functionality.

[0722] A "dependency graph" is a diagram that visually represents the dependencies between software components, clearly illustrating the interrelationships between each element.

[0723] A "malfunction" is a software error or defect that causes unintended behavior or results.

[0724] A "proposal for correction" is a specific instruction for change or improvement proposed to resolve a problem.

[0725] "Real-time monitoring" refers to activities that involve continuously observing data and having the ability to respond immediately, so that the latest status can always be understood.

[0726] "Operational stability" refers to a state in which a system continues to function correctly without unintended shutdowns or errors.

[0727] "Data analysis means" refers to a series of processes or methods for deriving useful insights using collected information.

[0728] To implement this invention, a system consisting of a server and a terminal is used. The server acquires software library information from an external information area and stores it in an internal information management device. The software used is Node.js, which performs real-time data processing. The data is exchanged in JSON format and managed using MongoDB. The server utilizes a generative AI model built using TensorFlow to detect potential defects and generate proposed fixes.

[0729] The device is developed using React Native and provides the user interface. The device displays a real-time interdependency graph generated by D3.js. Users can monitor the software's state through this graph and apply suggested fixes via the interface as needed. Furthermore, the device runs automated tests and sends the results to the server.

[0730] As a concrete example, suppose a data center operator manages the system's library status using a terminal. When the system updates a specified library, the AI ​​automatically predicts potential problems and provides appropriate solutions. This ensures the system remains stable. Furthermore, by inputting a prompt such as, "The system may have become unstable after installing the latest library. Please identify dependency issues and suggest solutions," the AI ​​model can provide rapid assistance.

[0731] This allows users to achieve efficient operation and manage library dependencies.

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

[0733] Step 1:

[0734] The server accesses an external information area to retrieve software library information. The input is a list of URLs for the external information area, and data is retrieved using a REST API. The output is library version information and dependency metadata. The retrieved data is in JSON format and is stored in MongoDB, the internal information management system.

[0735] Step 2:

[0736] The server analyzes the collected library information and generates an interdependency graph. The input is library information stored in MongoDB. The output is graph data that visualizes the dependencies between libraries. This process uses a Python library, and the graph is drawn using D3.js.

[0737] Step 3:

[0738] The terminal displays an interdependency graph generated through the user interface. When the user detects an anomaly, they can investigate it on the screen. The input is graph data sent from the server, and the output is a visualized graph on the user interface.

[0739] Step 4:

[0740] The server uses a generative AI model to detect potential bugs and generate suggested fixes. The input consists of a generated dependency graph and change history data. The output is a list of identified bugs and their corresponding suggested fixes. This process utilizes TensorFlow for AI-driven bug detection.

[0741] Step 5:

[0742] The terminal receives AI-generated correction suggestions and presents them on the user interface. The user can review the suggested corrections and apply them as needed. The input is the correction suggestions sent from the server, and the output is the state in which the correction suggestions are presented to the user.

[0743] Step 6:

[0744] The terminal runs automated tests and sends the results to the server. The input is the modified software code based on the applied fixes. The output is log data of the test results. The tests are performed quickly using CI / CD tools.

[0745] Step 7:

[0746] The server analyzes the test results and reports the verification results to the user. The input is log data of the test results sent from the terminal. The output is the analyzed verification results and their report. The results are displayed through the user interface, allowing the user to make a final confirmation.

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

[0748] This invention combines a system that automatically manages the dependencies of software components with an emotion engine that recognizes user emotions. This program processes as follows:

[0749] First, the server retrieves library information from an external data area via the internet. This information is stored in an internal database, where library versions and dependencies are managed. This allows the server to maintain the latest library information in real time and make it available to users.

[0750] The terminal generates a dependency graph using library information stored on the server and analyzes it. This graph is used to visualize the interrelationships between each library and to clearly show the dependencies between software components. If a potential bug is detected, the AI ​​model generates a suggested fix. At this stage, the terminal automatically updates the source code to fix the bug and avoid the problem.

[0751] In this process, users utilize the functions of the emotion engine. The emotion engine analyzes the user's emotions and combines this emotional information to adjust the interface when reporting bugs or suggesting fixes. As a result, it reduces user stress and provides a mechanism that allows users to operate the system more comfortably.

[0752] For example, if a user expresses dissatisfaction with a bug after a library update, the sentiment engine works to alleviate that dissatisfaction by providing a more detailed explanation of the proposed fix or prioritizing the provision of relevant information. Similarly, if a user feels unsure about operating the system, the sentiment engine provides guidance to improve the user experience.

[0753] Finally, the server analyzes the test results and reports the final verification findings to the user. This report includes feedback from the emotion engine and suggests solutions for any areas that need improvement. This ensures that the system is always operating optimally and meeting user needs.

[0754] The following describes the processing flow.

[0755] Step 1:

[0756] The server accesses an external data area and retrieves the latest library information via the internet. This information includes library version information and dependency metadata, which is stored in an internal database. The server keeps this database up-to-date to prepare for subsequent processing.

[0757] Step 2:

[0758] The terminal uses library information provided by the server to generate a dependency graph between software components within the system. The terminal analyzes this graph to understand in detail which components depend on which other libraries.

[0759] Step 3:

[0760] The device uses an AI model to analyze the generated dependency graph and detect potential bugs. This AI model refers to historical data to predict the likelihood of bugs caused by library updates.

[0761] Step 4:

[0762] The emotion engine analyzes the user's emotions in real time. When a user shows an emotional response to the system, the device receives feedback from the emotion engine and adjusts the priority of reports and how details are presented.

[0763] Step 5:

[0764] The device generates suggested fixes for bugs identified by the AI ​​model. Based on these, the device automatically updates the source code to comply with the new library specifications. This update process is carried out appropriately, taking into account the user's sentiment information.

[0765] Step 6:

[0766] The user runs tests to verify the validity of the code updates performed by the device. The user receives feedback from the sentiment engine and can adjust the interface as needed.

[0767] Step 7:

[0768] The server aggregates and analyzes the test results to confirm whether the bugs have been resolved. Along with the analysis results, the server provides the user with a report that includes feedback obtained from user sentiment data.

[0769] Step 8:

[0770] Once user approval is received, the server deploys the updated source code to the production environment and resumes normal system operation. During this process, it is also possible to continuously suggest improvements based on the user's emotional state.

[0771] (Example 2)

[0772] 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".

[0773] In software development, there is a growing need to automatically manage the increasingly complex dependencies between software components and to quickly detect and correct potential problems. Furthermore, optimizing the interface while considering the emotions of system users is also crucial. This invention aims to provide a system that effectively solves these problems.

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

[0775] In this invention, the server includes means for acquiring software component information from an external information area and storing it in an internal information recording device, means for analyzing the collected software component information and generating and comparing dependency diagrams, and means for analyzing user emotions and adaptively adjusting the interface. This makes it possible to efficiently manage software component dependencies, improve the user experience, and quickly identify and correct potential problems.

[0776] The "external information domain" is a source of information for collecting component information that can be accessed via a global information network.

[0777] "Software component information" refers to data containing information about the components of software, including version and dependency information.

[0778] An "internal information recording device" is a database or storage device used to store and manage software component information.

[0779] A "dependency diagram" is a diagram used to visualize the interrelationships between software components, and is a graph that shows the dependencies between them.

[0780] An "interface" is a point of contact for information exchange between a user and a system.

[0781] "Analyzing emotions" refers to the process of evaluating a user's emotional state from data and making decisions based on that information.

[0782] "Adaptively adjusting" means changing the behavior of an interface or system according to the situation or requirements.

[0783] "Rapidly identifying and fixing problems" refers to quickly detecting potential defects or issues and making appropriate corrections.

[0784] This invention provides a system that efficiently manages the dependencies of software components and offers an interface that responds to user emotions. This system operates based on the interaction between the server, terminal, and user.

[0785] The server retrieves software component information from an external information area via the internet. In this process, the server uses a REST API to collect publicly available component information. The collected information is received in JSON format and stored in a database. This database is used to manage library version information and dependencies.

[0786] The terminal generates a dependency diagram using this software component information stored on the server. The terminal uses graph database software (e.g., Neo4j) to create nodes for each software component and edges indicating their dependencies. This information is then plotted as a graph using a visualization tool (e.g., D3.js).

[0787] Users receive support through an emotion engine during this process. The emotion engine has the ability to analyze emotions from the user's input and system operation history. If a user shows frustration while using the system, for example, the emotion engine will adjust the interface and work to reduce stress. This allows users to use the system comfortably.

[0788] A concrete example is a case where a user encounters a bug after a library update and expresses dissatisfaction. In this case, the emotion engine provides a detailed explanation of the proposed bug fix and prioritizes the provision of relevant information. Furthermore, because this system utilizes a generative AI model, it has the ability to propose appropriate solutions tailored to the user's requests.

[0789] A concrete example of a prompt message would be, "Please tell me how to retrieve the latest component information, analyze the dependency diagram, and generate suggested fixes for the detected defects." This allows the system to respond quickly to user requests and provide the optimal solution.

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

[0791] Step 1:

[0792] The server retrieves software component information from an external information area. In this step, it receives the URL and authentication information of an external API as input and obtains a dataset of software components in JSON format as output. Specifically, the server communicates over the network via a REST API, retrieves library information from the specified repository, and writes it to the database.

[0793] Step 2:

[0794] The terminal generates a dependency diagram based on software component information obtained from the server. The input is software component information obtained from a database, and the output is graph data showing the dependencies. In this process, nodes and edges are generated in a graph database (e.g., Neo4j) to visually structure the relationships between components.

[0795] Step 3:

[0796] The terminal analyzes the generated dependency diagram to detect potential problems. The input is the data from the dependency graph, and the output is a list of problems and their details. In this step, machine learning algorithms are used to scan the graph and compare it with existing data models to identify inconsistencies and potential bugs.

[0797] Step 4:

[0798] The AI ​​model generates suggested solutions based on the detected problems. The input is a list of problems, and the output is specific suggested solutions. The generating AI model utilizes natural language processing techniques to propose the optimal solution, referencing past correction history and solutions to similar problems.

[0799] Step 5:

[0800] The device automatically updates the source code based on the proposed modifications generated by the AI ​​model. The input is the proposed modifications, and the output is the updated source code. This process applies the suggested changes to the existing code, ensuring code consistency and accuracy.

[0801] Step 6:

[0802] The server performs tests on the updated source code. The input is the updated source code, and the output is the test results. At this stage, unit tests and integration tests are performed through the CI / CD pipeline to confirm that the update functions as expected.

[0803] Step 7:

[0804] The server analyzes the test results and reports the final verification results to the user. The input is test result data, and the output is a verification report. Specifically, it aggregates the test results, generates a report including the cause and countermeasures if there are any problems, and notifies the user.

[0805] Step 8:

[0806] The user adjusts the system interface using an emotion engine. The input is the user's emotional data, and the output is the adjusted interface settings. The emotion engine analyzes the user's emotional state and adjusts the tone and amount of information in the interface as needed to optimize the user experience.

[0807] (Application Example 2)

[0808] 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".

[0809] In modern software development, managing component dependencies is complex and often leads to potential bugs. Furthermore, users frequently experience stress and anxiety during operation, in addition to these technical issues, which acts as a barrier to software use. Therefore, there is a need for technologies that simultaneously achieve effective dependency management and improved user experience.

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

[0811] In this invention, the server includes means for acquiring library information from an external information storage area and storing it in an internal information storage area; means for analyzing the collected library information and generating and comparing dependency graphs; means for detecting potential defects and generating necessary corrective measures; and means for analyzing user emotions and dynamically adjusting the interface. This enables efficient dependency management of software and reduces stress on the user while improving the user experience.

[0812] "Software components" refer to individual program parts that make up a program, such as libraries, modules, and frameworks.

[0813] A "dependency" refers to a relationship where one software component depends on another and operates in relation to them.

[0814] An "external information storage area" is a location on the internet or a network where various data and library information are stored.

[0815] "Library information" refers to data that includes version information and dependencies of program components and modules used in software development.

[0816] The "internal information storage area" is a storage area for temporarily or permanently storing data necessary for use within the system.

[0817] A "malfunction" refers to a problem where software does not function correctly or does not produce the expected results.

[0818] A "proposal for correction" refers to a specific plan or proposed change aimed at resolving a detected defect.

[0819] "Program code" refers to a set of instructions written to build software, or text used to give commands to a computer processor.

[0820] "Testing" refers to a specific testing process conducted to verify that software operates according to specifications.

[0821] "User emotions" refers to the emotions and psychological states expressed by users when using software.

[0822] An "interface" is an element that defines the screen display and operability when a user interacts with software.

[0823] "Stress reduction" refers to measures and functions designed to lower the psychological burden that users experience when using software.

[0824] This invention is a system for dynamically adjusting the interface by analyzing user emotions while efficiently managing the dependencies of software components.

[0825] The server retrieves library information from an external information storage area via the information and communication network and stores this data in its internal information storage unit. This information is important because it provides the data necessary for managing dependencies and analyzing defects.

[0826] The terminal analyzes library information obtained from the server, generates a dependency graph, and clearly shows the relationships between each library. This allows for the detection of potential bugs and the generation of suggested fixes as needed. Based on these suggested fixes, the program code is automatically updated, providing users with a highly reliable system.

[0827] Users operate the software through their devices, and during this process, an emotion analysis engine analyzes the user's facial expressions and voice tone to understand their emotions. Based on this emotional information, the interface is dynamically adjusted to improve the user experience. If the user feels stressed, the interface becomes more user-friendly; if they feel anxious, detailed guides and supplementary information are provided to reduce the psychological burden of using the software.

[0828] As a concrete example, if this system is implemented in a smartphone application, when an error occurs while the user is updating a library, the emotion engine can detect from the user's facial expression that they are experiencing stress. In this case, the app automatically displays a detailed explanation of the error and troubleshooting steps to alleviate the user's anxiety. It also provides the user with interactive guidance as needed. At this point, a generative AI model is used to determine the optimal approach based on the user's state.

[0829] An example of a prompt might be: "If the user feels uneasy during payment, suggest ways to display additional information and improve the user experience. How do you analyze the user's emotions and respond?"

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

[0831] Step 1:

[0832] The server retrieves library information from an external information storage area via an information and communication network. The input is library information from the external storage area, and the output is data stored in the internal information storage unit. The data is retrieved in real time and organized to maintain the latest library information.

[0833] Step 2:

[0834] The terminal receives library information provided by the server, analyzes that data, and generates a dependency graph. The input is library information obtained from the server, and the output is the generated dependency graph. The analysis checks the links of each library in the database and models their relationships in a visually understandable way.

[0835] Step 3:

[0836] The device uses the generated dependency graph to detect potential bugs and generate suggested fixes. The input is the dependency graph, and the output is the bugs and their suggested fixes. Here, a generative AI model is used to analyze bug patterns and calculate the optimal fix procedure.

[0837] Step 4:

[0838] The terminal automatically updates the program code based on the generated correction proposal. The input is the correction proposal, and the output is the updated program code. The system directly modifies the code and records the changes that are reflected.

[0839] Step 5:

[0840] The terminal performs tests to determine the validity of the updated code. The input is the updated program code, and the output is the test result. The tests verify operation in specific scenarios and collect data to confirm normal operation.

[0841] Step 6:

[0842] The server analyzes the test results and reports the findings to the user. The input is the test results, and the output is the report to the user. Using an emotion engine, the report is tailored to the user's situation and presented in text and graphics.

[0843] Step 7:

[0844] While the user operates the system through their device, their emotions are analyzed by an emotion analysis engine. The input is the user's facial expressions and voice during operation, and the output is the analyzed emotion data. Based on the emotion data, the interface is adjusted, and necessary guides and information are displayed.

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

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

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

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

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

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

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

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

[0853] 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."

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

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

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

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

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

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

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

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

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

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

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

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

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

[0867] (Claim 1)

[0868] A system that automatically manages the dependencies of software components,

[0869] A means of obtaining library information from an external data area and storing it in an internal database,

[0870] A means for analyzing collected library information, generating and matching dependency graphs,

[0871] A means for detecting potential defects and generating necessary corrective measures,

[0872] A means to automatically update the source code based on the generated revision proposals,

[0873] A means of running tests to determine the validity of the updated code,

[0874] A system including means for analyzing the aforementioned test results and reporting the verification results.

[0875] (Claim 2)

[0876] The system according to claim 1, characterized in that the external data area is a library repository accessible via the Internet.

[0877] (Claim 3)

[0878] The system according to claim 1, characterized in that the detection of the aforementioned potential defects and the generation of corrective measures are performed by a machine learning model.

[0879] "Example 1"

[0880] (Claim 1)

[0881] A means for acquiring software information from an information area and storing it in a storage device,

[0882] A means for analyzing collected software information and generating and inspecting dependency structures,

[0883] A means of using machine learning models to detect potential problems and generate optimal solutions,

[0884] A means of automatically updating the program code based on the generated correction proposals,

[0885] A means of performing automated tests on the updated code and determining its validity,

[0886] A system including means for processing and analyzing the aforementioned test results and notifying the evaluation results.

[0887] (Claim 2)

[0888] The system according to claim 1, characterized in that the information domain is a software repository that can be connected via a network.

[0889] (Claim 3)

[0890] The system according to claim 1, characterized in that the detection of the aforementioned potential problem and the generation of proposed solutions are performed by a generative AI model.

[0891] "Application Example 1"

[0892] (Claim 1)

[0893] A system that automatically manages the dependencies of software components,

[0894] A means for acquiring software library information from an external information area and storing it in an internal information management device,

[0895] A means for analyzing collected software library information, generating and comparing interdependency graphs,

[0896] A means for detecting potential defects and generating necessary corrective measures,

[0897] A means of automatically updating the program code based on the generated correction proposals,

[0898] A means of running tests to determine the validity of the updated code,

[0899] A means for analyzing the aforementioned test results and reporting the verification results,

[0900] A data analysis tool to monitor the status of software libraries in real time and support operational stability,

[0901] A means of notifying update information via the user interface,

[0902] A system that includes this.

[0903] (Claim 2)

[0904] The system according to claim 1, characterized in that the external information area is an information repository accessible via a network.

[0905] (Claim 3)

[0906] The system according to claim 1, characterized in that the detection of the aforementioned potential defects and the generation of corrective measures are performed by an artificial intelligence model.

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

[0908] (Claim 1)

[0909] A means for acquiring software component information from an external information area and storing it in an internal information recording device,

[0910] A means for analyzing collected software component information, generating and comparing dependency diagrams,

[0911] A means to detect potential problems and generate necessary corrective measures,

[0912] A means to automatically update the rewrite based on the generated proposed revisions,

[0913] A means of performing a check to determine the validity of the rewrite after the update,

[0914] A means for analyzing the aforementioned test results and reporting the verification results,

[0915] A means of analyzing user emotions and adaptively adjusting the interface,

[0916] A system that includes means to improve the user experience based on emotion analysis.

[0917] (Claim 2)

[0918] The system according to claim 1, characterized in that the external information domain is a parts collection point accessible via a global information network.

[0919] (Claim 3)

[0920] The system according to claim 1, characterized in that the detection of the aforementioned potential problem and the generation of proposed solutions are performed by a learning algorithm model.

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

[0922] (Claim 1)

[0923] A mechanism that automatically manages the dependencies of software components and analyzes user emotions,

[0924] A means for obtaining library information from an external information storage area and storing it in an internal information storage unit,

[0925] A means for analyzing collected library information, generating and matching dependency graphs,

[0926] A means for detecting potential defects and generating necessary corrective measures,

[0927] A means of automatically updating the program code based on the generated correction proposals,

[0928] A means of performing tests to determine the validity of the updated code,

[0929] A means for analyzing the aforementioned test results and reporting the verification results,

[0930] A means of analyzing user emotions and dynamically adjusting the interface,

[0931] A means of providing a guide to improve the user experience,

[0932] A mechanism that includes this.

[0933] (Claim 2)

[0934] The mechanism according to claim 1, characterized in that the external information storage area is a library information public access site accessible via an information and communication network.

[0935] (Claim 3)

[0936] The mechanism according to claim 1, characterized in that the detection of the aforementioned potential defects and the generation of corrective measures are performed by a learning machine model. [Explanation of Symbols]

[0937] 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 system that automatically manages the dependencies of software components, A means of obtaining library information from an external data area and storing it in an internal database, A means for analyzing collected library information, generating and matching dependency graphs, A means for detecting potential defects and generating necessary corrective measures, A means to automatically update the source code based on the generated revision proposals, A means of running tests to determine the validity of the updated code, A system including means for analyzing the aforementioned test results and reporting the verification results.

2. The system according to claim 1, characterized in that the external data area is a library repository accessible via the Internet.

3. The system according to claim 1, characterized in that the detection of the aforementioned potential defects and the generation of corrective measures are performed by a machine learning model.

Images