System

Abstract

A system is provided.SOLUTION: The system includes a means for acquiring a source code from a Git repository, a means for analyzing the acquired source code and calculating the ratio of a program language, a means for analyzing a setting file in the source code and extracting dependency, a means for visualizing an analysis result and displaying it on a user interface, and a means for proposing the reading order of a program on the basis of the analysis result.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

[0003] [Patent Document 1] Japanese Patent Publication No. 2022-180282 Summary of the Invention [Problem to be solved by the invention]

[0004] In software development projects, it is difficult for new engineers to quickly understand the existing code base. When taking over a project, it takes a lot of time and effort to understand the overall code structure, programming languages ​​used, and major dependencies. A system to solve this problem is needed. [Means for solving the problem]

[0005] This invention is a system that includes a means for retrieving source code from a Git repository, analyzing the retrieved source code, calculating the proportion of programming languages, analyzing configuration files in the source code and extracting dependencies, visualizing the analysis results and displaying them in a user interface, and proposing a program interpretation order based on the analysis results, allowing new engineers to efficiently catch up on existing projects.

[0006] A "Git repository" is a collection of source code managed using a version control system called Git.

[0007] "Source code" is a text file written in a programming language that instructs how a program should operate.

[0008] A "means of retrieval" is a method or technology for downloading source code from a specified Git repository and storing it in a local environment.

[0009] "Means for analysis" refers to methods and techniques for analyzing the contents of the acquired source code based on the programming language and dependencies.

[0010] "Proportion of programming languages" is the percentage of each programming language in all source code files in the repository.

[0011] A "configuration file" is a file used to define dependencies, environment settings, and architectural configurations in a software project.

[0012] A "dependency extraction method" is a method or technique for identifying and listing the libraries and modules that a project depends on from configuration files.

[0013] "Means for visualizing and displaying on a user interface" refers to methods and techniques for displaying analysis results in a graphical or text format that is easy for users to view.

[0014] A "means for suggesting a reading order" is a method or technique that, based on the analysis results, suggests which file or directory an engineer should start reading from in order to efficiently understand the source code. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0023] [First embodiment]

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

[0025] 1, a data processing system 10 includes a data processing device 12 and a smart device 14. An example of the data processing device 12 is a server.

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

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

[0028] The reception device 38 includes a touch panel 38A, a microphone 38B, and the like, and receives user input. The touch panel 38A detects contact with an indicator (for example, a pen or a finger) to receive user input by the touch of the indicator. The microphone 38B detects the user's voice to receive user input by voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the data indicating the user input.

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

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

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

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

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

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

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

[0036] This invention is a system called a "Program Handover Assistant" that helps new engineers quickly catch up on a project by retrieving and analyzing source code from a Git repository. A specific embodiment of the system is described below.

[0037] Specifying and cloning a repository

[0038] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[0039] The server clones the repository from the URL you entered. The server uses the Git API to download the repository to a virtual directory. Once this download is complete, the server proceeds to the next step.

[0040] Language analysis

[0041] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, and counts the number of files in each programming language.

[0042] The server then calculates the percentage of each programming language used in the repository, based on the results of the calculations, and determines the proportion of languages ​​used within the repository.

[0043] Parsing the configuration file

[0044] The server analyzes the key configuration files in the repository (e.g., package.json, requirements.txt). It parses these files and lists the libraries and modules that the project depends on.

[0045] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[0046] Information Visualization

[0047] The device displays the analysis results received from the server on the user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[0048] The device provides a graphical dashboard that allows engineers to intuitively understand the overall picture of the project, displaying heat maps and graphs.

[0049] Presenting the reading order

[0050] Based on the analysis, the server suggests the order in which the engineer should start reading files and directories. The server suggests starting with important configuration files and entry points for the project.

[0051] The terminal displays a suggested reading order in the user interface, allowing new engineers to efficiently begin understanding the code base.

[0052] Specific examples

[0053] Let's say a new engineer joins a project that's a web application that uses Python and JavaScript. The user enters the repository URL, and the server clones the repository. The server then analyzes the source code and determines that it's 60% Python and 40% JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each.

[0054] The terminal displays this information on a dashboard, and the server suggests an appropriate reading order (e.g., Django app settings file settings.py, main URL setting urls.py, React entry point index.js). Engineers can start reading the code in this order and quickly catch up on the project.

[0055] This implementation allows new engineers to efficiently understand the project from the critical parts and contribute quickly.

[0056] The processing flow will be explained below.

[0057] Step 1:

[0058] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[0059] Step 2:

[0060] The server receives the URL entered by the user and clones the repository. The server uses the Git API to download the repository to the project directory on the server. At this time, it logs the success / failure of the clone process.

[0061] Step 3:

[0062] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, identifies the language for each file, and counts the number of files in each programming language.

[0063] Step 4:

[0064] Calculate the proportion of each programming language used in the repository based on the number of files counted by the server. Express these proportions as a percentage to clarify the overall language distribution.

[0065] Step 5:

[0066] The server finds and reads key configuration files in the repository (e.g., package.json, requirements.txt), parses these files, and extracts information about the libraries and modules that the project depends on.

[0067] Step 6:

[0068] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[0069] Step 7:

[0070] The device displays the analysis results received from the server on the user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[0071] Step 8:

[0072] The terminal provides a graphical dashboard that allows users to intuitively understand the overall picture of the project, displaying heat maps and graphs.

[0073] Step 9:

[0074] Based on the analysis, the server will suggest the order in which the user should start reading the code from, starting from the files and directories. The server will recommend starting with the project's important configuration files and entry points.

[0075] Step 10:

[0076] The device will display the suggested reading order in the user interface, allowing the user to start reading the code in this order and efficiently catch up on the project.

[0077] Example 1

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

[0079] It is difficult for new engineers joining a software project to quickly understand the overall picture of the project and its detailed dependencies. With traditional methods, it takes a lot of time and effort for new engineers to quickly get up to speed on the project, which slows down the progress of the project. There is a need for a system that can efficiently understand the project's code base.

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

[0081] In this invention, the server includes a means for receiving a repository URL specified by a user and cloning the repository, a means for scanning all files in the cloned repository to identify programming languages ​​used and calculate the proportion of each language, and a means for analyzing major configuration files and extracting project dependencies, which allows new engineers to quickly grasp the overall picture and dependencies of the project and efficiently understand the code base.

[0082] "User" refers to a person who uses the system and is the entity that performs specific operations or inputs.

[0083] A "repository" is a type of database that stores software source code and version control information.

[0084] A "URL" is a string of characters that indicates the location of a resource on the Internet.

[0085] "Clone" refers to the operation of duplicating the contents of a repository to a local environment.

[0086] A "file" is a unit for storing data, and includes program code and setting information.

[0087] "Scanning" is the process of examining the entire file system and extracting specific information.

[0088] A "programming language" is a formal language for writing computer programs.

[0089] A "ratio" is a number that indicates the proportion of an individual element to the whole.

[0090] A "configuration file" is a file used to specify software behavior and dependencies.

[0091] A "dependency" refers to a relationship in which a software module depends on another module.

[0092] "Analysis" is the process of examining data or systems in detail to derive specific information.

[0093] "Visualization" is a method of displaying abstract data graphically to make it easier to understand.

[0094] "User interface" refers to the screen and operating means that allow a user to interact with a system.

[0095] A "reading order" is an order indicating the recommended reading priority for understanding software code.

[0096] This invention relates to a "program handover assistant" system. This system assists new engineers in quickly catching up with a project by retrieving and analyzing source code from a Git repository. Specific embodiments are described below.

[0097] Specifying and cloning a repository

[0098] A user accesses the system and enters the URL of the Git repository they want to take over into the web interface. After the user enters the URL, the server receives it and uses the Git API to clone the repository into a virtual directory. Specifically, the server executes "git clone https: / / github.com / example / project-url" and downloads the contents of the repository.

[0099] Language analysis

[0100] The server scans all files in the cloned repository and identifies the programming language of each file based on its extension. For example, it identifies .py files as Python and .js files as JavaScript. The server then tallies the number of files in each language and calculates their percentage of the total. This information helps engineers understand how much of each programming language is used in a project.

[0101] Parsing the configuration file

[0102] The server parses the main configuration files in the repository (e.g., package.json, requirements.txt) and generates a list of libraries and modules that the project depends on. Specifically, it extracts Django and numpy from requirements.txt, and React and axios from package.json. The server analyzes these dependencies and gathers information to create an overview of the project's architecture.

[0103] Information Visualization

[0104] The terminal displays the analysis results received from the server in a user interface. The analysis results include the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The terminal also provides a graphical dashboard, such as a heat map or pie chart, to help engineers intuitively understand the overall picture of the project.

[0105] Presenting the reading order

[0106] Based on the analysis results, the server suggests an order in which engineers should start reading files and directories. This order recommends starting with important configuration files and entry points for the project. The terminal displays the suggested reading order in a user interface, allowing new engineers to efficiently begin understanding the codebase.

[0107] Specific examples

[0108] Consider a new engineer joining a web application project that uses Python and JavaScript. The user enters the repository URL "https: / / github.com / example / project-url." The server clones the repository from this URL and determines that 60% of the code is Python and 40% is JavaScript. The server analyzes requirements.txt and package.json and lists dependencies such as Django, numpy, React, and axios, respectively. The terminal displays this information on a dashboard, using pie charts and heat maps to help the engineer intuitively understand it. The server then suggests the order in which to parse Django's settings.py, urls.py, React's index.js, etc., and the terminal displays it.

[0109] This system allows new engineers to efficiently start understanding the key parts of a project and contribute quickly.

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

[0111] Step 1:

[0112] The user accesses the system's web interface and enters the URL of the Git repository they want to take over into a text box. When the user enters the URL, it is sent to the server. Specifically, the user enters "https: / / github.com / example / project-url."

[0113] Step 2:

[0114] The server receives the URL and uses the Git API to clone the repository into a virtual directory. The command for this clone operation is "git clone https: / / github.com / example / project-url". The input is the repository URL, and the output is the contents of the cloned repository in the virtual directory.

[0115] Step 3:

[0116] The server scans all files in the cloned repository. It identifies the programming language based on the file extension of each file, for example, identifying ".py" files as Python and ".js" files as JavaScript. The input is all files in the repository, and the output is the identification result for each programming language.

[0117] Step 4:

[0118] The server counts the number of files for each identified programming language. Specifically, it counts how many Python files there are, how many JavaScript files there are, etc. The input is the programming language identification result, and the output is the number of files for each language and their proportion.

[0119] Step 5:

[0120] The server parses key configuration files, e.g. package.json and requirements.txt, and extracts dependent libraries and modules, such as React and axios from package.json, and Django and numpy from requirements.txt. The input is the configuration files in the cloned repository, and the output is the list of extracted dependencies.

[0121] Step 6:

[0122] The server analyzes dependencies and gathers an overview of the project's architecture, including how each library and module is related. The input is a list of dependencies, and the output is an overview of the project's architecture.

[0123] Step 7:

[0124] The terminal displays the analysis results received from the server in a user interface. The displayed content includes the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. For example, a pie chart or heat map is displayed. The input is the server's analysis results, and the output is graphical information displayed on the dashboard.

[0125] Step 8:

[0126] Based on the analysis results, the server suggests the order in which the engineer should start reading from which files and directories. For example, it suggests the reading order for Django's settings.py, urls.py, React's index.js, etc. The input is the analysis results, and the output is the suggested reading order.

[0127] Step 9:

[0128] The terminal displays the suggested parsing order in a user interface, allowing new engineers to efficiently begin understanding the codebase. The input is the parsing order suggested by the server, and the output is what is displayed in the user interface.

[0129] (Application example 1)

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

[0131] When introducing new software to existing industrial machinery, it is difficult to understand the proper installation order, checking the settings and dependencies, and there are challenges that require time and effort.In addition, there is insufficient support to help new engineers quickly get up to speed on the project, making it difficult to carry out the project smoothly.

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

[0133] In this invention, the server includes means for retrieving source code from a Git repository, means for analyzing the retrieved source code and calculating the proportion of program languages, means for analyzing configuration files in the source code and extracting dependencies, means for visualizing and displaying the analysis results on a user interface, means for proposing a program interpretation order based on the analysis results, and means for installing new software on industrial machines and quickly completing the configuration, thereby enabling new software to be introduced to industrial machines quickly and efficiently and enabling new engineers to smoothly catch up on the project.

[0134] A "Git repository" is a database used in a distributed version control system to manage source code and change history.

[0135] "Source code" is the original code of a computer program written in a particular programming language.

[0136] A "programming language" is an artificial language for writing computer programs, and is a means by which humans give instructions to computers.

[0137] A "dependency" is a relationship in which a software component depends on another component to function.

[0138] A "configuration file" is a text file that describes the operating environment and operation settings of the software.

[0139] "Visualization" is the process of graphically representing data and analysis results to make them easier to understand intuitively.

[0140] A "user interface" is an interface through which humans interact with computers.

[0141] "Industrial machinery" is a general term for machinery and robots used in manufacturing and production industries.

[0142] "Installation" is the process of introducing software onto a computer system and making its functionality available.

[0143] "Configuration" is the process of preparing the parameters and environment necessary for software to perform a specific operation.

[0144] The present invention is a system for quickly and efficiently installing new software on industrial machines and completing the setup, and is implemented by the following steps.

[0145] Specifying and cloning a repository

[0146] The user enters the URL of the Git repository they want to take over through a web interface. The server clones the repository from the URL. Specifically, it uses the Git API to download the repository to a virtual directory. Once the download is complete, the server proceeds to the next step.

[0147] Language analysis

[0148] The server scans all files in the cloned repository, determines the programming language based on the file extension of each file, counts the number of files in each programming language, and then calculates the percentage of languages ​​used in the repository.

[0149] Parsing the configuration file

[0150] The server analyzes the main configuration files in the repository (e.g. requirements.txt, package.json), parses these files, lists the libraries and modules that the project depends on, analyzes the dependencies, and gathers information to get an overview of the project's architecture.

[0151] Information Visualization

[0152] The terminal displays the analysis results received from the server in a user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The terminal provides a graphical dashboard, allowing industrial machine operators to intuitively understand the overall picture of the project.

[0153] Presenting the reading order

[0154] Based on the analysis results, the server will suggest the order in which the operator should start reading files and directories, suggesting starting with important configuration files and entry points, optimizing the configuration order.

[0155] As a concrete example, suppose a new engineer joins an industrial software project that uses Python and JavaScript. The user enters the repository URL and the server clones the repository. The server then analyzes the source code and determines that 60% of the code is Python and 40% is JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each. The terminal displays this information on a dashboard, and the server also suggests an appropriate reading order. The operator can start reading the code in this order and quickly catch up on the project.

[0156] An example prompt for a generative AI model might look like this:

[0157] "What is the best procedure for installing and configuring new software on an industrial machine? Considering the code's language mix and dependencies."

[0158] "Analyze a Git repository and automatically generate software setup instructions for an industrial machine. Determine the order based on configuration files and key modules."

[0159] This embodiment allows for the rapid and efficient introduction of new software to industrial machines, allowing new engineers to smoothly get up to speed on projects.

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

[0161] Step 1:

[0162] The user enters the URL of the Git repository they want to take over via a web interface, which provides the Git repository URL as input and sends it to the server.

[0163] Step 2:

[0164] The server clones the repository from the URL entered using the Git API. The clone process downloads the repository's source code into a virtual directory. As output, a copy of the source code is created in the local directory.

[0165] Step 3:

[0166] The server scans all files in the virtual directory and determines the programming language based on the file extension. The input is the source code files in the virtual directory, and the output is a count of the number of files in each programming language.

[0167] Step 4:

[0168] The server calculates the percentage of each programming language based on the results of the aggregation. The number of files per extension obtained in step 3 is used as input, and the percentage of each programming language is calculated as output.

[0169] Step 5:

[0170] The server parses important configuration files (e.g. requirements.txt, package.json) and extracts dependencies. It takes the contents of the configuration files as input and generates a list of dependencies as output.

[0171] Step 6:

[0172] The server further analyzes the dependencies to get an overview of the project's architecture, specifically the dependencies between the main modules and the configuration parameters, using the information in the configuration files as input and providing information about the project's architecture as output.

[0173] Step 7:

[0174] The server sends the analysis results to the terminal, which displays them on a user interface. The terminal receives the analysis results as input and displays them in a graphical dashboard as output. The dashboard includes the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[0175] Step 8:

[0176] The server proposes a file or directory parsing order based on the parsing results. It uses the parsing results as input and generates an appropriate parsing order as output.

[0177] Step 9:

[0178] The terminal displays the suggested deciphering sequence in a user interface to enable the operator to efficiently understand the code. The suggested deciphering sequence is provided to the terminal as input and displayed in the user interface as output.

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

[0180] This invention is a system called a "Program Handover Assistant" that retrieves source code from a Git repository and analyzes it to help new engineers quickly get up to speed on a project. Furthermore, by combining it with an emotion engine that recognizes user emotions, the user experience can be improved. A specific embodiment of the system is described below.

[0181] Specifying and cloning a repository

[0182] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[0183] The server clones the repository from the URL you entered. The server uses the Git API to download the repository to a project directory on the server. Once this download is complete, the server proceeds to the next step.

[0184] Language analysis

[0185] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, and counts the number of files in each programming language.

[0186] The server then calculates the percentage of each programming language used in the repository, based on the results of the calculations, and determines the proportion of languages ​​used within the repository.

[0187] Parsing the configuration file

[0188] The server analyzes the key configuration files in the repository (e.g., package.json, requirements.txt). It parses these files and lists the libraries and modules that the project depends on.

[0189] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[0190] Information Visualization

[0191] The device displays the analysis results received from the server on the user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[0192] The device provides a graphical dashboard that allows engineers to intuitively understand the overall picture of the project, displaying heat maps and graphs.

[0193] Presenting the reading order

[0194] Based on the analysis, the server will suggest the order in which the engineer should start reading files and directories. The server will suggest starting with the project's important configuration files and entry points.

[0195] The terminal will display a suggested reading order in the user interface, allowing the engineer to start reading the code in this order and efficiently catch up on the project.

[0196] Emotion engine integration

[0197] The emotion engine analyzes the user's facial expressions and voice to recognize emotions in real time. The user's emotional data is collected and analyzed through the camera and microphone.

[0198] The server receives the analysis results of the emotion engine and dynamically changes the content and presentation of the user interface. For example, if the user is feeling stressed, the server will provide more considerate explanations and guidance.

[0199] Specific examples

[0200] Let's say a new engineer joins a project that's a web application that uses Python and JavaScript. The user enters the repository URL, and the server clones the repository. The server then analyzes the source code and determines that it's 60% Python and 40% JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each.

[0201] The terminal displays this information on a dashboard, and the server suggests an appropriate reading order (e.g., Django app settings file settings.py, main URL setting urls.py, React entry point index.js). Engineers can start reading the code in this order and quickly catch up on the project.

[0202] Furthermore, the emotion engine analyzes the user's facial expressions and voice in real time, and if the user is confused, the server adjusts the user interface to provide more detailed guidance and support, such as step-by-step navigation and demonstrations to help the user learn.

[0203] This embodiment allows new engineers to efficiently understand the project from the important parts and contribute quickly, and the emotion engine provides appropriate support according to the user's state, improving learning efficiency.

[0204] The processing flow will be explained below.

[0205] Step 1:

[0206] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[0207] Step 2:

[0208] The server receives the URL entered by the user and clones the repository. The server uses the Git API to download the repository to the project directory on the server. At this time, it logs the success / failure of the clone process.

[0209] Step 3:

[0210] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, identifies the language for each file, and counts the number of files in each programming language.

[0211] Step 4:

[0212] Calculate the proportion of each programming language used in the repository based on the number of files counted by the server. Express these proportions as a percentage to clarify the overall language distribution.

[0213] Step 5:

[0214] The server finds and reads key configuration files in the repository (e.g., package.json, requirements.txt), parses these files, and extracts information about the libraries and modules that the project depends on.

[0215] Step 6:

[0216] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[0217] Step 7:

[0218] The terminal displays the analysis results received from the server in a user interface. The analysis results include the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The user interface is displayed in a visually easy-to-understand format.

[0219] Step 8:

[0220] The terminal provides a graphical dashboard that gives users an intuitive overview of the project, displaying heat maps and graphs that users can use to gain a better understanding of key codebases.

[0221] Step 9:

[0222] Based on the analysis, the server will suggest the order in which the user should start reading the code from, starting with the project's important configuration files and entry point files.

[0223] Step 10:

[0224] The terminal will display the suggested reading order on the user interface, allowing the user to start reading the code in this order and catch up on the project efficiently, thereby saving time and effort.

[0225] Step 11:

[0226] The emotion engine analyzes the user's facial expressions and voice in real time to recognize their emotions. It also collects emotional data through the camera and microphone to detect when the user is confused or stressed.

[0227] Step 12:

[0228] The server receives the analysis results of the emotion engine and dynamically changes the content and presentation of the user interface. For example, if the user is confused, it can provide more detailed guidance or step-by-step navigation, or display encouraging messages to motivate the user.

[0229] Step 13:

[0230] The device reflects the feedback from the emotion engine and provides the optimal user interface for the user, allowing the user to use the system comfortably and effectively progress with their learning and work.

[0231] Example 2

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

[0233] Traditionally, new engineers have struggled to quickly get up to speed on projects. These challenges include the difficulty of understanding the languages ​​and dependencies used within the repository, the time it takes to read code in an inappropriate order, and the lack of a way to recognize user emotions and improve learning efficiency. A new system is needed to address these challenges.

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

[0235] In this invention, the server includes means for retrieving source code from a Git repository, means for analyzing the retrieved source code to calculate the proportion of programming languages, means for analyzing configuration files in the source code to extract dependencies, means for visualizing the analysis results and displaying them in a user interface, means for proposing a program interpretation order based on the analysis results, means for recognizing and analyzing user emotions, and means for dynamically changing the content and presentation method of the user interface based on the emotion analysis results. This allows new engineers to efficiently catch up on projects and improves learning efficiency by providing appropriate support based on user emotions.

[0236] "Source code" is the text data of a program that defines the behavior of software.

[0237] A "Git repository" is a database used to manage source code and its change history in the Git version control system.

[0238] "Means" are specific technical means such as methods or devices for achieving a specific purpose.

[0239] "Analysis" is the process of breaking down information and clarifying its components and relationships.

[0240] A "programming language" is a set of rules and notations for creating programs that are executed by a computer.

[0241] "User interface" refers to the means or methods for inputting and outputting information between a user and a system.

[0242] A "dependency" is a relationship in which a piece of software depends on other specific software or libraries to function.

[0243] An "emotion engine" refers to an algorithm or device for recognizing and analyzing a user's emotions.

[0244] "Dynamic change" refers to changing content or settings in real time depending on the situation.

[0245] A "reading order" is the recommended order in which to begin reading a program or document in order to understand its contents in the proper order.

[0246] This invention is a system called "Program Handover Assistant" that retrieves source code from a Git repository and analyzes it to help new engineers quickly get up to speed on a project. Furthermore, by integrating an emotion engine that recognizes user emotions, the user experience can be improved. A specific embodiment of the system is described in detail below.

[0247] Specifying and cloning a repository

[0248] A user accesses the system and enters the URL of the Git repository they want to transfer. This is done through a web interface. The server clones the repository from the URL using the Git API and downloads it to the project directory on the server.

[0249] Language analysis

[0250] The server scans all files in the cloned repository, identifies the programming language based on the file extension, counts the number of files in each programming language, and calculates the percentage of each programming language used in the repository.

[0251] Parsing the configuration file

[0252] The server analyzes the main configuration files in the repository (e.g. package.json, requirements.txt). It parses these files to list the libraries and modules that the project depends on. It then analyzes the dependencies and gets an overview of the project's architecture.

[0253] Information Visualization

[0254] The terminal displays the analysis results received from the server on a user interface. The analysis results include the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The terminal also provides a graphical dashboard that allows engineers to intuitively understand the overall picture of the project. The dashboard displays heat maps and graphs.

[0255] Presenting the reading order

[0256] Based on the analysis results, the server will suggest to the engineer the appropriate order in which to read files and directories, allowing the engineer to start reading from important configuration files and entry points, and efficiently catch up on the project.

[0257] Emotion engine integration

[0258] The emotion engine analyzes the user's facial expressions and voice to recognize emotions in real time. It collects and analyzes the user's emotional data through a camera and microphone. The server dynamically changes the content and presentation of the user interface based on the emotion engine's analysis results. For example, if the user is feeling stressed, it will provide more considerate explanations and guidance.

[0259] Specific examples

[0260] Let's say a new engineer joins a project that's a web application that uses Python and JavaScript. The user enters the repository URL, and the server clones the repository. The server then analyzes the source code and determines that it's 60% Python and 40% JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each.

[0261] The terminal displays this information on a dashboard, and the server suggests an appropriate reading order (e.g., Django app settings file settings.py, main URL setting urls.py, React entry point index.js). Engineers can start reading the code in this order and quickly catch up on the project.

[0262] Furthermore, the emotion engine analyzes the user's facial expressions and voice in real time, and if the user is confused, the server adjusts the user interface to provide more detailed guidance and support, such as step-by-step navigation and demonstrations to help the user learn.

[0263] Prompt Sentence Examples

[0264] Describe a system that helps engineers joining a new project understand the project efficiently. This system retrieves source code from a Git repository, displays the analysis results on a dashboard, and suggests an appropriate reading order. It also includes a function that uses an emotion engine to recognize user emotions in real time and provide appropriate guidance. As a concrete example, imagine a web application project using Python and JavaScript.

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

[0266] Step 1:

[0267] Specifying and cloning a repository

[0268] A user accesses the system and enters the URL of the Git repository they want to take over, which is then entered into a text box on the web interface.

[0269] The server takes the input URL and clones the specified repository using the Git API. This operation downloads the entire contents of the repository into a project directory on the server. The input is the Git repository URL, and the output is the downloaded repository files.

[0270] Step 2:

[0271] Language analysis

[0272] The server scans all files in the downloaded repository, and this scanning is done using the file system API.

[0273] The server checks the extension of each file and determines the programming language based on that. For example, if the extension is ".py", it is determined to be Python, and if it is ".js", it is determined to be JavaScript.

[0274] The server counts the number of files in each identified programming language and calculates the percentage of the repository that each programming language occupies. The input is the file extension, and the output is the usage rate of each programming language.

[0275] Step 3:

[0276] Parsing the configuration file

[0277] The server identifies key configuration files in the repository (e.g., package.json, requirements.txt) and loads them.

[0278] The server parses the contents of the configuration file and lists the libraries and modules that the project depends on, using a JSON parser or text analysis tool.

[0279] The server analyzes dependencies and understands the relationships between major modules. The input is a configuration file, and the output is a list of dependent libraries and modules.

[0280] Step 4:

[0281] Information Visualization

[0282] The server generates and sends the analysis results to the device, which include the percentage of programming languages ​​used, a list of dependent libraries, and a summary of the project's architecture.

[0283] A graphical dashboard is provided based on the analysis results received by the device. This dashboard displays heat maps and various graphs. The input is the analysis result data, and the output is the displayed dashboard.

[0284] Step 5:

[0285] Presenting the reading order

[0286] Based on the analysis, the server recommends the order in which the engineer should start reading from, prioritizing important configuration files and entry points.

[0287] The terminal displays the recommended parsing order in the user interface, and the engineer can start reading the code according to this order. The input is the parsing result, and the output is the recommended parsing order.

[0288] Step 6:

[0289] Emotion engine integration

[0290] The emotion engine analyzes the user's facial expressions and voice in real time to recognize their emotional state, using data collected through the camera and microphone.

[0291] The server receives the analysis results of the emotion engine and dynamically changes the content and presentation of the user interface depending on the user's stress level or confusion, for example, by providing more detailed guidance or step-by-step explanations. The input is emotion data, and the output is an adjusted user interface.

[0292] This allows new engineers to efficiently understand the project from the key parts in the repository and quickly catch up, and the emotion engine provides appropriate support.

[0293] (Application example 2)

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

[0295] With the advancement of information technology, it has become common for many companies and organizations to use multiple programming languages ​​and libraries in software development projects. However, when new engineers join a project, it is difficult for them to understand the code base and dependencies within the project and quickly catch up. Furthermore, maintaining factory robots requires an understanding of complex systems, making it difficult for new engineers to work efficiently in a short period of time. In addition, stress and confusion can cause a significant drop in work efficiency. An effective method to solve these problems is needed.

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

[0297] In this invention, the server includes means for retrieving source code from a Git repository, means for analyzing the retrieved source code and calculating the proportion of programming languages, means for analyzing configuration files in the source code and extracting dependencies, means for visualizing the analysis results and displaying them in a user interface, means for proposing a program interpretation order based on the analysis results, means for recognizing emotions by analyzing a user's facial expressions and voice, and means for dynamically changing the content and presentation method of the user interface based on the emotion recognition results. This not only enables new engineers to quickly catch up on projects and factory robot systems and work efficiently, but also enables optimal support to be provided according to the user's emotional state.

[0298] A "Git repository" is a database for version control in software development, which tracks the change history of source code and allows multiple developers to work together.

[0299] "Source code" means computer program instructions written in a programming language in a form that can be understood and executed by a computer.

[0300] "Programming language proportion" is a metric that indicates the usage rate of various programming languages ​​used within a particular project or repository, and represents the proportion of each language in the total.

[0301] A "configuration file" is a file that describes various settings and dependencies in a software project, and specifically includes version information for libraries and modules.

[0302] A "dependency" refers to a relationship in which one software component or module depends on another component or module, such that one component requires the other component to function correctly.

[0303] "Visualization" refers to the visual representation of data or information, which makes it easier for users to intuitively understand the information.

[0304] A "user interface" is an interface that allows a user to interact with a computer system, and is operated using a graphical display and input device.

[0305] A "reading order" is the order in which a new engineer should read through the files and directories to understand the source code of a project.

[0306] "Facial expressions" are expressions on a human face that change to show emotions and intentions.

[0307] "Speech" refers to the sound produced by the human voice and is used to convey various information, including emotions and intentions.

[0308] "Emotion recognition" is a technology that analyzes a user's facial expressions and voice to estimate their emotional state at that time.

[0309] "Dynamic change" means that the system automatically changes its content and behavior in real time according to the situation, thereby providing users with the most appropriate information and operating methods.

[0310] This invention provides a "Robot Maintenance Assistant" that streamlines factory robot maintenance and helps new engineers quickly understand the system. Specific embodiments of this system are described below.

[0311] 1. Server Processing

[0312] The server receives the URL of the Git repository specified by the user. Based on the URL entered by the user, the server uses the Git API to clone the repository and save it to a local directory. The server then analyzes the saved source code to determine the proportion of programming languages ​​used and dependencies. To analyze dependencies, it parses the main configuration files in the repository (e.g., package.json and requirements.txt).

[0313] 2. Information visualization

[0314] The results of the analysis by the server are displayed on a graphical dashboard. Information such as the proportion of various programming languages, an overview of dependencies, and the main architecture is visually displayed, allowing engineers to intuitively understand it. For this purpose, the dashboard library is used.

[0315] 3. Suggested reading order

[0316] Based on the analysis results, the server will suggest which files and directories the engineer should start reading from, especially important configuration files and entry point files, allowing the engineer to catch up efficiently.

[0317] 4. Emotion recognition

[0318] The server is equipped with an emotion engine (e.g., the emotion_recognition library) that analyzes the user's facial expressions and voice in real time and recognizes their emotions. Emotional data is collected through a camera and microphone, and the content and presentation of the interface are dynamically changed if the user is feeling stressed or confused. Specifically, it provides more detailed guidance and step-by-step navigation.

[0319] 5. Specific Examples

[0320] Imagine a new maintenance engineer at a factory needs to quickly understand a Git repository for control software for a new industrial robot. The user enters the repository URL, and the server clones and analyzes it. The analysis results are displayed on a dashboard, showing the proportion of programming languages ​​and dependencies at a glance. An emotion engine monitors the user's facial expressions and voice, and if stress or confusion is detected, it provides detailed instructions and guidance.

[0321] Prompt Sentence Examples

[0322] You are designing an assistant to help factory maintenance engineers quickly understand the Git repository for a new robotics system. The system will clone and analyze the repository, visualize the results, and dynamically adjust the interface based on emotion recognition. Write the code to implement this system using Python.

[0323] In this way, the invention not only helps new engineers quickly get up to speed on projects, but also creates a system that provides optimal support depending on the emotions that arise during the process.

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

[0325] Step 1:

[0326] The user accesses the system's web interface and enters the URL of the Git repository they want to take over, which is then sent to the server.

[0327] Step 2:

[0328] The server receives the URL of the Git repository and clones it using the Git API. At this time, the source code of the cloned repository is downloaded to a local directory. The input is the repository URL, and the output is the source code saved in the local directory.

[0329] Step 3:

[0330] The server scans the source code stored in the local directory and determines the programming language used based on the file extension of each file. It then counts the number of files for each identified programming language and calculates the percentage of each language in the total. The input is the source code, and the output is the percentage of programming languages.

[0331] Step 4:

[0332] The server parses the main configuration files in the repository (e.g., package.json, requirements.txt) and extracts dependencies. It parses each configuration file and lists the libraries and modules that the project depends on. The input is the configuration file, and the output is the list of dependencies.

[0333] Step 5:

[0334] The server processes the percentage of programming languages ​​and the list of dependencies into data for display on a graphical dashboard and sends it to the terminal. The input is the percentage of programming languages ​​and the list of dependencies, and the output is the data for displaying on the dashboard.

[0335] Step 6:

[0336] The terminal receives the data sent from the server and displays the analysis results on a graphical dashboard. The percentage of languages ​​used, a list of dependencies, and an overview of the architecture are visually displayed. The input is the data to be displayed on the dashboard, and the output is the displayed dashboard.

[0337] Step 7:

[0338] Based on the analysis, the server suggests an order in which the engineer should start reading files and directories, recommending that they start with the main configuration file or entry point. The input is the analysis results, and the output is the suggested parsing order.

[0339] Step 8:

[0340] The terminal displays the parsing order received from the server on the user interface. The engineer can start reading the code according to this order. The input is the parsing order, and the output is the order displayed on the user interface.

[0341] Step 9:

[0342] The server uses an emotion engine to analyze the user's facial expressions and voice in real time to recognize emotions. Emotion data is collected through the camera and microphone and analyzed. The input is data from the camera and microphone, and the output is the recognized emotion.

[0343] Step 10:

[0344] The server dynamically changes the content and presentation of the user interface based on the emotion recognition results. If the user is feeling stressed, it provides detailed guidance and step-by-step navigation. The input is the recognized emotion, and the output is the dynamically changed user interface.

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

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

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

[0348] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

[0359] In the smart glasses 214, the reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

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

[0361] This invention is a system called a "Program Handover Assistant" that helps new engineers quickly catch up on a project by retrieving and analyzing source code from a Git repository. A specific embodiment of the system is described below.

[0362] Specifying and cloning a repository

[0363] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[0364] The server clones the repository from the URL you entered. The server uses the Git API to download the repository to a virtual directory. Once this download is complete, the server proceeds to the next step.

[0365] Language analysis

[0366] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, and counts the number of files in each programming language.

[0367] The server then calculates the percentage of each programming language used in the repository, based on the results of the calculations, and determines the proportion of languages ​​used within the repository.

[0368] Parsing the configuration file

[0369] The server analyzes the key configuration files in the repository (e.g., package.json, requirements.txt). It parses these files and lists the libraries and modules that the project depends on.

[0370] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[0371] Information Visualization

[0372] The device displays the analysis results received from the server on the user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[0373] The device provides a graphical dashboard that allows engineers to intuitively understand the overall picture of the project, displaying heat maps and graphs.

[0374] Presenting the reading order

[0375] Based on the analysis, the server suggests the order in which the engineer should start reading files and directories. The server suggests starting with important configuration files and entry points for the project.

[0376] The terminal displays a suggested reading order in the user interface, allowing new engineers to efficiently begin understanding the code base.

[0377] Specific examples

[0378] Let's say a new engineer joins a project that's a web application that uses Python and JavaScript. The user enters the repository URL, and the server clones the repository. The server then analyzes the source code and determines that it's 60% Python and 40% JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each.

[0379] The terminal displays this information on a dashboard, and the server suggests an appropriate reading order (e.g., Django app settings file settings.py, main URL setting urls.py, React entry point index.js). Engineers can start reading the code in this order and quickly catch up on the project.

[0380] This implementation allows new engineers to efficiently understand the project from the critical parts and contribute quickly.

[0381] The processing flow will be explained below.

[0382] Step 1:

[0383] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[0384] Step 2:

[0385] The server receives the URL entered by the user and clones the repository. The server uses the Git API to download the repository to the project directory on the server. At this time, it logs the success / failure of the clone process.

[0386] Step 3:

[0387] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, identifies the language for each file, and counts the number of files in each programming language.

[0388] Step 4:

[0389] Calculate the proportion of each programming language used in the repository based on the number of files counted by the server. Express these proportions as a percentage to clarify the overall language distribution.

[0390] Step 5:

[0391] The server finds and reads key configuration files in the repository (e.g., package.json, requirements.txt), parses these files, and extracts information about the libraries and modules that the project depends on.

[0392] Step 6:

[0393] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[0394] Step 7:

[0395] The device displays the analysis results received from the server on the user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[0396] Step 8:

[0397] The terminal provides a graphical dashboard that allows users to intuitively understand the overall picture of the project, displaying heat maps and graphs.

[0398] Step 9:

[0399] Based on the analysis, the server will suggest the order in which the user should start reading the code from, starting from the files and directories. The server will recommend starting with the project's important configuration files and entry points.

[0400] Step 10:

[0401] The device will display the suggested reading order in the user interface, allowing the user to start reading the code in this order and efficiently catch up on the project.

[0402] Example 1

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

[0404] It is difficult for new engineers joining a software project to quickly understand the overall picture of the project and its detailed dependencies. With traditional methods, it takes a lot of time and effort for new engineers to quickly get up to speed on the project, which slows down the progress of the project. There is a need for a system that can efficiently understand the project's code base.

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

[0406] In this invention, the server includes a means for receiving a repository URL specified by a user and cloning the repository, a means for scanning all files in the cloned repository to identify programming languages ​​used and calculate the proportion of each language, and a means for analyzing major configuration files and extracting project dependencies, which allows new engineers to quickly grasp the overall picture and dependencies of the project and efficiently understand the code base.

[0407] "User" refers to a person who uses the system and is the entity that performs specific operations or inputs.

[0408] A "repository" is a type of database that stores software source code and version control information.

[0409] A "URL" is a string of characters that indicates the location of a resource on the Internet.

[0410] "Clone" refers to the operation of duplicating the contents of a repository to a local environment.

[0411] A "file" is a unit for storing data, and includes program code and setting information.

[0412] "Scanning" is the process of examining the entire file system and extracting specific information.

[0413] A "programming language" is a formal language for writing computer programs.

[0414] A "ratio" is a number that indicates the proportion of an individual element to the whole.

[0415] A "configuration file" is a file used to specify software behavior and dependencies.

[0416] A "dependency" refers to a relationship in which a software module depends on another module.

[0417] "Analysis" is the process of examining data or systems in detail to derive specific information.

[0418] "Visualization" is a method of displaying abstract data graphically to make it easier to understand.

[0419] "User interface" refers to the screen and operating means that allow a user to interact with a system.

[0420] A "reading order" is an order indicating the recommended reading priority for understanding software code.

[0421] This invention relates to a "program handover assistant" system. This system assists new engineers in quickly catching up with a project by retrieving and analyzing source code from a Git repository. Specific embodiments are described below.

[0422] Specifying and cloning a repository

[0423] A user accesses the system and enters the URL of the Git repository they want to take over into the web interface. After the user enters the URL, the server receives it and uses the Git API to clone the repository into a virtual directory. Specifically, the server executes "git clone https: / / github.com / example / project-url" and downloads the contents of the repository.

[0424] Language analysis

[0425] The server scans all files in the cloned repository and identifies the programming language of each file based on its extension. For example, it identifies .py files as Python and .js files as JavaScript. The server then tallies the number of files in each language and calculates their percentage of the total. This information helps engineers understand how much of each programming language is used in a project.

[0426] Parsing the configuration file

[0427] The server parses the main configuration files in the repository (e.g., package.json, requirements.txt) and generates a list of libraries and modules that the project depends on. Specifically, it extracts Django and numpy from requirements.txt, and React and axios from package.json. The server analyzes these dependencies and gathers information to create an overview of the project's architecture.

[0428] Information Visualization

[0429] The terminal displays the analysis results received from the server in a user interface. The analysis results include the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The terminal also provides a graphical dashboard, such as a heat map or pie chart, to help engineers intuitively understand the overall picture of the project.

[0430] Presenting the reading order

[0431] Based on the analysis results, the server suggests an order in which engineers should start reading files and directories. This order recommends starting with important configuration files and entry points for the project. The terminal displays the suggested reading order in a user interface, allowing new engineers to efficiently begin understanding the codebase.

[0432] Specific examples

[0433] Consider a new engineer joining a web application project that uses Python and JavaScript. The user enters the repository URL "https: / / github.com / example / project-url." The server clones the repository from this URL and determines that 60% of the code is Python and 40% is JavaScript. The server analyzes requirements.txt and package.json and lists dependencies such as Django, numpy, React, and axios, respectively. The terminal displays this information on a dashboard, using pie charts and heat maps to help the engineer intuitively understand it. The server then suggests the order in which to parse Django's settings.py, urls.py, React's index.js, etc., and the terminal displays it.

[0434] This system allows new engineers to efficiently start understanding the key parts of a project and contribute quickly.

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

[0436] Step 1:

[0437] The user accesses the system's web interface and enters the URL of the Git repository they want to take over into a text box. When the user enters the URL, it is sent to the server. Specifically, the user enters "https: / / github.com / example / project-url."

[0438] Step 2:

[0439] The server receives the URL and uses the Git API to clone the repository into a virtual directory. The command for this clone operation is "git clone https: / / github.com / example / project-url". The input is the repository URL, and the output is the contents of the cloned repository in the virtual directory.

[0440] Step 3:

[0441] The server scans all files in the cloned repository. The specific operation of identifying the programming language based on the extension of each file is, for example, identifying ".py" files as Python and ".js" files as JavaScript. The input is all files in the repository, and the output is the identification result for each programming language.

[0442] Step 4:

[0443] The server counts the number of files for each identified programming language. Specifically, it counts how many Python files there are, how many JavaScript files there are, etc. The input is the programming language identification result, and the output is the number of files for each language and their proportion.

[0444] Step 5:

[0445] The server parses key configuration files, e.g. package.json and requirements.txt, and extracts dependent libraries and modules, such as React and axios from package.json, and Django and numpy from requirements.txt. The input is the configuration files in the cloned repository, and the output is the list of extracted dependencies.

[0446] Step 6:

[0447] The server analyzes dependencies and gathers an overview of the project's architecture, including how each library and module is related. The input is a list of dependencies, and the output is an overview of the project's architecture.

[0448] Step 7:

[0449] The terminal displays the analysis results received from the server in a user interface. The displayed content includes the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. For example, a pie chart or heat map is displayed. The input is the server's analysis results, and the output is graphical information displayed on the dashboard.

[0450] Step 8:

[0451] Based on the analysis results, the server suggests the order in which the engineer should start reading from which files and directories. For example, it suggests the reading order for Django's settings.py, urls.py, React's index.js, etc. The input is the analysis results, and the output is the suggested reading order.

[0452] Step 9:

[0453] The terminal displays the suggested parsing order in a user interface, allowing new engineers to efficiently begin understanding the codebase. The input is the parsing order suggested by the server, and the output is what is displayed in the user interface.

[0454] (Application example 1)

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

[0456] When introducing new software to existing industrial machinery, it is difficult to understand the proper installation order, checking the settings and dependencies, and there are challenges that require time and effort.In addition, there is insufficient support to help new engineers quickly get up to speed on the project, making it difficult to carry out the project smoothly.

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

[0458] In this invention, the server includes means for retrieving source code from a Git repository, means for analyzing the retrieved source code and calculating the proportion of program languages, means for analyzing configuration files in the source code and extracting dependencies, means for visualizing and displaying the analysis results on a user interface, means for proposing a program interpretation order based on the analysis results, and means for installing new software on industrial machines and quickly completing the configuration, thereby enabling new software to be introduced to industrial machines quickly and efficiently and enabling new engineers to smoothly catch up on the project.

[0459] A "Git repository" is a database used in a distributed version control system to manage source code and change history.

[0460] "Source code" is the original code of a computer program written in a particular programming language.

[0461] A "programming language" is an artificial language for writing computer programs, and is a means by which humans give instructions to computers.

[0462] A "dependency" is a relationship in which a software component depends on another component to function.

[0463] A "configuration file" is a text file that describes the operating environment and operation settings of the software.

[0464] "Visualization" is the process of graphically representing data and analysis results to make them easier to understand intuitively.

[0465] A "user interface" is an interface through which humans interact with computers.

[0466] "Industrial machinery" is a general term for machinery and robots used in manufacturing and production industries.

[0467] "Installation" is the process of introducing software onto a computer system and making its functionality available.

[0468] "Configuration" is the process of preparing the parameters and environment necessary for software to perform a specific operation.

[0469] The present invention is a system for quickly and efficiently installing new software on industrial machines and completing the setup, and is implemented by the following steps.

[0470] Specifying and cloning a repository

[0471] The user enters the URL of the Git repository they want to take over through a web interface. The server clones the repository from the URL. Specifically, it uses the Git API to download the repository to a virtual directory. Once the download is complete, the server proceeds to the next step.

[0472] Language analysis

[0473] The server scans all files in the cloned repository, determines the programming language based on the file extension of each file, counts the number of files in each programming language, and then calculates the percentage of languages ​​used in the repository.

[0474] Parsing the configuration file

[0475] The server analyzes the main configuration files in the repository (e.g. requirements.txt, package.json), parses these files, lists the libraries and modules that the project depends on, analyzes the dependencies, and gathers information to get an overview of the project's architecture.

[0476] Information Visualization

[0477] The terminal displays the analysis results received from the server in a user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The terminal provides a graphical dashboard, allowing industrial machine operators to intuitively understand the overall picture of the project.

[0478] Presenting the reading order

[0479] Based on the analysis results, the server will suggest the order in which the operator should start reading files and directories, suggesting starting with important configuration files and entry points, optimizing the configuration order.

[0480] As a concrete example, suppose a new engineer joins an industrial software project that uses Python and JavaScript. The user enters the repository URL and the server clones the repository. The server then analyzes the source code and determines that 60% of the code is Python and 40% is JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each. The terminal displays this information on a dashboard, and the server also suggests an appropriate reading order. The operator can start reading the code in this order and quickly catch up on the project.

[0481] An example prompt for a generative AI model might look like this:

[0482] "What is the best procedure for installing and configuring new software on an industrial machine? Considering the code's language mix and dependencies."

[0483] "Analyze a Git repository and automatically generate software setup instructions for an industrial machine. Determine the order based on configuration files and key modules."

[0484] This embodiment allows for the rapid and efficient introduction of new software to industrial machines, allowing new engineers to smoothly get up to speed on projects.

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

[0486] Step 1:

[0487] The user enters the URL of the Git repository they want to take over via a web interface, which provides the Git repository URL as input and sends it to the server.

[0488] Step 2:

[0489] The server clones the repository from the URL entered using the Git API. The clone process downloads the repository's source code into a virtual directory. As output, a copy of the source code is created in the local directory.

[0490] Step 3:

[0491] The server scans all files in the virtual directory and determines the programming language based on the file extension. The input is the source code files in the virtual directory, and the output is a count of the number of files in each programming language.

[0492] Step 4:

[0493] The server calculates the percentage of each programming language based on the results of the aggregation. The number of files per extension obtained in step 3 is used as input, and the percentage of each programming language is calculated as output.

[0494] Step 5:

[0495] The server parses important configuration files (e.g. requirements.txt, package.json) and extracts dependencies. It takes the contents of the configuration files as input and generates a list of dependencies as output.

[0496] Step 6:

[0497] The server further analyzes the dependencies to get an overview of the project's architecture, specifically the dependencies between the main modules and the configuration parameters, using the information in the configuration files as input and providing information about the project's architecture as output.

[0498] Step 7:

[0499] The server sends the analysis results to the terminal, which displays them on a user interface. The terminal receives the analysis results as input and displays them in a graphical dashboard as output. The dashboard includes the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[0500] Step 8:

[0501] The server proposes a file or directory parsing order based on the parsing results. It uses the parsing results as input and generates an appropriate parsing order as output.

[0502] Step 9:

[0503] The terminal displays the suggested deciphering sequence in a user interface to enable the operator to efficiently understand the code. The suggested deciphering sequence is provided to the terminal as input and displayed in the user interface as output.

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

[0505] This invention is a system called a "Program Handover Assistant" that retrieves source code from a Git repository and analyzes it to help new engineers quickly get up to speed on a project. Furthermore, by combining it with an emotion engine that recognizes user emotions, the user experience can be improved. A specific embodiment of the system is described below.

[0506] Specifying and cloning a repository

[0507] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[0508] The server clones the repository from the URL you entered. The server uses the Git API to download the repository to a project directory on the server. Once this download is complete, the server proceeds to the next step.

[0509] Language analysis

[0510] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, and counts the number of files in each programming language.

[0511] The server then calculates the percentage of each programming language used in the repository, based on the results of the calculations, and determines the proportion of languages ​​used within the repository.

[0512] Parsing the configuration file

[0513] The server analyzes the key configuration files in the repository (e.g., package.json, requirements.txt). It parses these files and lists the libraries and modules that the project depends on.

[0514] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[0515] Information Visualization

[0516] The device displays the analysis results received from the server on the user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[0517] The device provides a graphical dashboard that allows engineers to intuitively understand the overall picture of the project, displaying heat maps and graphs.

[0518] Presenting the reading order

[0519] Based on the analysis, the server will suggest the order in which the engineer should start reading files and directories. The server will suggest starting with the project's important configuration files and entry points.

[0520] The terminal will display a suggested reading order in the user interface, allowing the engineer to start reading the code in this order and efficiently catch up on the project.

[0521] Emotion engine integration

[0522] The emotion engine analyzes the user's facial expressions and voice to recognize emotions in real time. The user's emotional data is collected and analyzed through the camera and microphone.

[0523] The server receives the analysis results of the emotion engine and dynamically changes the content and presentation of the user interface. For example, if the user is feeling stressed, the server will provide more considerate explanations and guidance.

[0524] Specific examples

[0525] Let's say a new engineer joins a project that's a web application that uses Python and JavaScript. The user enters the repository URL, and the server clones the repository. The server then analyzes the source code and determines that it's 60% Python and 40% JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each.

[0526] The terminal displays this information on a dashboard, and the server suggests an appropriate reading order (e.g., Django app settings file settings.py, main URL setting urls.py, React entry point index.js). Engineers can start reading the code in this order and quickly catch up on the project.

[0527] Furthermore, the emotion engine analyzes the user's facial expressions and voice in real time, and if the user is confused, the server adjusts the user interface to provide more detailed guidance and support, such as step-by-step navigation and demonstrations to help the user learn.

[0528] This embodiment allows new engineers to efficiently understand the project from the important parts and contribute quickly, and the emotion engine provides appropriate support according to the user's state, improving learning efficiency.

[0529] The processing flow will be explained below.

[0530] Step 1:

[0531] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[0532] Step 2:

[0533] The server receives the URL entered by the user and clones the repository. The server uses the Git API to download the repository to the project directory on the server. At this time, it logs the success / failure of the clone process.

[0534] Step 3:

[0535] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, identifies the language for each file, and counts the number of files in each programming language.

[0536] Step 4:

[0537] Calculate the proportion of each programming language used in the repository based on the number of files counted by the server. Express these proportions as a percentage to clarify the overall language distribution.

[0538] Step 5:

[0539] The server finds and reads key configuration files in the repository (e.g., package.json, requirements.txt), parses these files, and extracts information about the libraries and modules that the project depends on.

[0540] Step 6:

[0541] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[0542] Step 7:

[0543] The terminal displays the analysis results received from the server in a user interface. The analysis results include the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The user interface is displayed in a visually easy-to-understand format.

[0544] Step 8:

[0545] The terminal provides a graphical dashboard that gives users an intuitive overview of the project, displaying heat maps and graphs that users can use to gain a better understanding of key codebases.

[0546] Step 9:

[0547] Based on the analysis, the server will suggest the order in which the user should start reading the code from, starting with the project's important configuration files and entry point files.

[0548] Step 10:

[0549] The terminal will display the suggested reading order on the user interface, allowing the user to start reading the code in this order and catch up on the project efficiently, thereby saving time and effort.

[0550] Step 11:

[0551] The emotion engine analyzes the user's facial expressions and voice in real time to recognize their emotions. It also collects emotional data through the camera and microphone to detect when the user is confused or stressed.

[0552] Step 12:

[0553] The server receives the analysis results of the emotion engine and dynamically changes the content and presentation of the user interface. For example, if the user is confused, it can provide more detailed guidance or step-by-step navigation, or display encouraging messages to motivate the user.

[0554] Step 13:

[0555] The device reflects the feedback from the emotion engine and provides the optimal user interface for the user, allowing the user to use the system comfortably and effectively progress with their learning and work.

[0556] Example 2

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

[0558] Traditionally, new engineers have struggled to quickly get up to speed on projects. These challenges include the difficulty of understanding the languages ​​and dependencies used within the repository, the time it takes to read code in an inappropriate order, and the lack of a way to recognize user emotions and improve learning efficiency. A new system is needed to address these challenges.

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

[0560] In this invention, the server includes means for retrieving source code from a Git repository, means for analyzing the retrieved source code to calculate the proportion of programming languages, means for analyzing configuration files in the source code to extract dependencies, means for visualizing the analysis results and displaying them in a user interface, means for proposing a program interpretation order based on the analysis results, means for recognizing and analyzing user emotions, and means for dynamically changing the content and presentation method of the user interface based on the emotion analysis results. This allows new engineers to efficiently catch up on projects and improves learning efficiency by providing appropriate support based on user emotions.

[0561] "Source code" is the text data of a program that defines the behavior of software.

[0562] A "Git repository" is a database used to manage source code and its change history in the Git version control system.

[0563] "Means" are specific technical means such as methods or devices for achieving a specific purpose.

[0564] "Analysis" is the process of breaking down information and clarifying its components and relationships.

[0565] A "programming language" is a set of rules and notations for creating programs that are executed by a computer.

[0566] "User interface" refers to the means or methods for inputting and outputting information between a user and a system.

[0567] A "dependency" is a relationship in which a piece of software depends on other specific software or libraries to function.

[0568] An "emotion engine" refers to an algorithm or device for recognizing and analyzing a user's emotions.

[0569] "Dynamic change" refers to changing content or settings in real time depending on the situation.

[0570] A "reading order" is the recommended order in which to begin reading a program or document in order to understand its contents in the proper order.

[0571] This invention is a system called "Program Handover Assistant" that retrieves source code from a Git repository and analyzes it to help new engineers quickly get up to speed on a project. Furthermore, by integrating an emotion engine that recognizes user emotions, the user experience can be improved. A specific embodiment of the system is described in detail below.

[0572] Specifying and cloning a repository

[0573] A user accesses the system and enters the URL of the Git repository they want to transfer. This is done through a web interface. The server clones the repository from the URL using the Git API and downloads it to the project directory on the server.

[0574] Language analysis

[0575] The server scans all files in the cloned repository, identifies the programming language based on the file extension, counts the number of files in each programming language, and calculates the percentage of each programming language used in the repository.

[0576] Parsing the configuration file

[0577] The server analyzes the main configuration files in the repository (e.g. package.json, requirements.txt). It parses these files to list the libraries and modules that the project depends on. It then analyzes the dependencies and gets an overview of the project's architecture.

[0578] Information Visualization

[0579] The terminal displays the analysis results received from the server on a user interface. The analysis results include the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The terminal also provides a graphical dashboard that allows engineers to intuitively understand the overall picture of the project. The dashboard displays heat maps and graphs.

[0580] Presenting the reading order

[0581] Based on the analysis results, the server will suggest to the engineer the appropriate order in which to read files and directories, allowing the engineer to start reading from important configuration files and entry points, and efficiently catch up on the project.

[0582] Emotion engine integration

[0583] The emotion engine analyzes the user's facial expressions and voice to recognize emotions in real time. It collects and analyzes the user's emotional data through a camera and microphone. The server dynamically changes the content and presentation of the user interface based on the emotion engine's analysis results. For example, if the user is feeling stressed, it will provide more considerate explanations and guidance.

[0584] Specific examples

[0585] Let's say a new engineer joins a project that's a web application that uses Python and JavaScript. The user enters the repository URL, and the server clones the repository. The server then analyzes the source code and determines that it's 60% Python and 40% JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each.

[0586] The terminal displays this information on a dashboard, and the server suggests an appropriate reading order (e.g., Django app settings file settings.py, main URL setting urls.py, React entry point index.js). Engineers can start reading the code in this order and quickly catch up on the project.

[0587] Furthermore, the emotion engine analyzes the user's facial expressions and voice in real time, and if the user is confused, the server adjusts the user interface to provide more detailed guidance and support, such as step-by-step navigation and demonstrations to help the user learn.

[0588] Prompt Sentence Examples

[0589] Describe a system that helps engineers joining a new project understand the project efficiently. This system retrieves source code from a Git repository, displays the analysis results on a dashboard, and suggests an appropriate reading order. It also includes a function that uses an emotion engine to recognize user emotions in real time and provide appropriate guidance. As a concrete example, imagine a web application project using Python and JavaScript.

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

[0591] Step 1:

[0592] Specifying and cloning a repository

[0593] A user accesses the system and enters the URL of the Git repository they want to take over, which is then entered into a text box on the web interface.

[0594] The server takes the input URL and clones the specified repository using the Git API. This operation downloads the entire contents of the repository into a project directory on the server. The input is the Git repository URL, and the output is the downloaded repository files.

[0595] Step 2:

[0596] Language analysis

[0597] The server scans all files in the downloaded repository, and this scanning is done using the file system API.

[0598] The server checks the extension of each file and determines the programming language based on that. For example, if the extension is ".py", it is determined to be Python, and if it is ".js", it is determined to be JavaScript.

[0599] The server counts the number of files in each identified programming language and calculates the percentage of the repository that each programming language occupies. The input is the file extension, and the output is the usage rate of each programming language.

[0600] Step 3:

[0601] Parsing the configuration file

[0602] The server identifies key configuration files in the repository (e.g., package.json, requirements.txt) and loads them.

[0603] The server parses the contents of the configuration file and lists the libraries and modules that the project depends on, using a JSON parser or text analysis tool.

[0604] The server analyzes dependencies and understands the relationships between major modules. The input is a configuration file, and the output is a list of dependent libraries and modules.

[0605] Step 4:

[0606] Information Visualization

[0607] The server generates and sends the analysis results to the device, which include the percentage of programming languages ​​used, a list of dependent libraries, and a summary of the project's architecture.

[0608] A graphical dashboard is provided based on the analysis results received by the device. This dashboard displays heat maps and various graphs. The input is the analysis result data, and the output is the displayed dashboard.

[0609] Step 5:

[0610] Presenting the reading order

[0611] Based on the analysis, the server recommends the order in which the engineer should start reading from, prioritizing important configuration files and entry points.

[0612] The terminal displays the recommended parsing order in the user interface, and the engineer can start reading the code according to this order. The input is the parsing result, and the output is the recommended parsing order.

[0613] Step 6:

[0614] Emotion engine integration

[0615] The emotion engine analyzes the user's facial expressions and voice in real time to recognize their emotional state, using data collected through the camera and microphone.

[0616] The server receives the analysis results of the emotion engine and dynamically changes the content and presentation of the user interface depending on the user's stress level or confusion, for example, by providing more detailed guidance or step-by-step explanations. The input is emotion data, and the output is an adjusted user interface.

[0617] This allows new engineers to efficiently understand the project from the key parts in the repository and quickly catch up, and the emotion engine provides appropriate support.

[0618] (Application example 2)

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

[0620] With the advancement of information technology, it has become common for many companies and organizations to use multiple programming languages ​​and libraries in software development projects. However, when new engineers join a project, it is difficult for them to understand the code base and dependencies within the project and quickly catch up. Furthermore, maintaining factory robots requires an understanding of complex systems, making it difficult for new engineers to work efficiently in a short period of time. In addition, stress and confusion can cause a significant drop in work efficiency. An effective method to solve these problems is needed.

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

[0622] In this invention, the server includes means for retrieving source code from a Git repository, means for analyzing the retrieved source code and calculating the proportion of programming languages, means for analyzing configuration files in the source code and extracting dependencies, means for visualizing the analysis results and displaying them in a user interface, means for proposing a program interpretation order based on the analysis results, means for recognizing emotions by analyzing a user's facial expressions and voice, and means for dynamically changing the content and presentation method of the user interface based on the emotion recognition results. This not only enables new engineers to quickly catch up on projects and factory robot systems and work efficiently, but also enables optimal support to be provided according to the user's emotional state.

[0623] A "Git repository" is a database for version control in software development, which tracks the change history of source code and allows multiple developers to work together.

[0624] "Source code" means computer program instructions written in a programming language in a form that can be understood and executed by a computer.

[0625] "Programming language proportion" is a metric that indicates the usage rate of various programming languages ​​used within a particular project or repository, and represents the proportion of each language in the total.

[0626] A "configuration file" is a file that describes various settings and dependencies in a software project, and specifically includes version information for libraries and modules.

[0627] A "dependency" refers to a relationship in which one software component or module depends on another component or module, such that one component requires the other component to function correctly.

[0628] "Visualization" refers to the visual representation of data or information, which makes it easier for users to intuitively understand the information.

[0629] A "user interface" is an interface that allows a user to interact with a computer system, and is operated using a graphical display and input device.

[0630] A "reading order" is the order in which a new engineer should read through the files and directories to understand the source code of a project.

[0631] "Facial expressions" are expressions on a human face that change to show emotions and intentions.

[0632] "Speech" refers to the sound produced by the human voice and is used to convey various information, including emotions and intentions.

[0633] "Emotion recognition" is a technology that analyzes a user's facial expressions and voice to estimate their emotional state at that time.

[0634] "Dynamic change" means that the system automatically changes its content and behavior in real time according to the situation, thereby providing users with the most appropriate information and operating methods.

[0635] This invention provides a "Robot Maintenance Assistant" that streamlines factory robot maintenance and helps new engineers quickly understand the system. Specific embodiments of this system are described below.

[0636] 1. Server Processing

[0637] The server receives the URL of the Git repository specified by the user. Based on the URL entered by the user, the server uses the Git API to clone the repository and save it to a local directory. The server then analyzes the saved source code to determine the proportion of programming languages ​​used and dependencies. To analyze dependencies, it parses the main configuration files in the repository (e.g., package.json and requirements.txt).

[0638] 2. Information visualization

[0639] The results of the analysis by the server are displayed on a graphical dashboard. Information such as the proportion of various programming languages, an overview of dependencies, and the main architecture is visually displayed, allowing engineers to intuitively understand it. For this purpose, the dashboard library is used.

[0640] 3. Suggested reading order

[0641] Based on the analysis results, the server will suggest which files and directories the engineer should start reading from, especially important configuration files and entry point files, allowing the engineer to catch up efficiently.

[0642] 4. Emotion recognition

[0643] The server is equipped with an emotion engine (e.g., the emotion_recognition library) that analyzes the user's facial expressions and voice in real time and recognizes their emotions. Emotional data is collected through a camera and microphone, and the content and presentation of the interface are dynamically changed if the user is feeling stressed or confused. Specifically, it provides more detailed guidance and step-by-step navigation.

[0644] 5. Specific Examples

[0645] Imagine a new maintenance engineer at a factory needs to quickly understand a Git repository for control software for a new industrial robot. The user enters the repository URL, and the server clones and analyzes it. The analysis results are displayed on a dashboard, showing the proportion of programming languages ​​and dependencies at a glance. An emotion engine monitors the user's facial expressions and voice, and if stress or confusion is detected, it provides detailed instructions and guidance.

[0646] Prompt Sentence Examples

[0647] You are designing an assistant to help factory maintenance engineers quickly understand the Git repository for a new robotics system. The system will clone and analyze the repository, visualize the results, and dynamically adjust the interface based on emotion recognition. Write the code to implement this system using Python.

[0648] In this way, the invention not only helps new engineers quickly get up to speed on projects, but also creates a system that provides optimal support depending on the emotions that arise during the process.

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

[0650] Step 1:

[0651] The user accesses the system's web interface and enters the URL of the Git repository they want to take over, which is then sent to the server.

[0652] Step 2:

[0653] The server receives the URL of the Git repository and clones it using the Git API. At this time, the source code of the cloned repository is downloaded to a local directory. The input is the repository URL, and the output is the source code saved in the local directory.

[0654] Step 3:

[0655] The server scans the source code stored in the local directory and determines the programming language used based on the file extension of each file. It then counts the number of files for each identified programming language and calculates the percentage of each language in the total. The input is the source code, and the output is the percentage of programming languages.

[0656] Step 4:

[0657] The server parses the main configuration files in the repository (e.g., package.json, requirements.txt) and extracts dependencies. It parses each configuration file and lists the libraries and modules that the project depends on. The input is the configuration file, and the output is the list of dependencies.

[0658] Step 5:

[0659] The server processes the percentage of programming languages ​​and the list of dependencies into data for display on a graphical dashboard and sends it to the terminal. The input is the percentage of programming languages ​​and the list of dependencies, and the output is the data for displaying on the dashboard.

[0660] Step 6:

[0661] The terminal receives the data sent from the server and displays the analysis results on a graphical dashboard. The percentage of languages ​​used, a list of dependencies, and an overview of the architecture are visually displayed. The input is the data to be displayed on the dashboard, and the output is the displayed dashboard.

[0662] Step 7:

[0663] Based on the analysis, the server suggests an order in which the engineer should start reading files and directories, recommending that they start with the main configuration file or entry point. The input is the analysis results, and the output is the suggested parsing order.

[0664] Step 8:

[0665] The terminal displays the parsing order received from the server on the user interface. The engineer can start reading the code according to this order. The input is the parsing order, and the output is the order displayed on the user interface.

[0666] Step 9:

[0667] The server uses an emotion engine to analyze the user's facial expressions and voice in real time to recognize emotions. Emotion data is collected through the camera and microphone and analyzed. The input is data from the camera and microphone, and the output is the recognized emotion.

[0668] Step 10:

[0669] The server dynamically changes the content and presentation of the user interface based on the emotion recognition results. If the user is feeling stressed, it provides detailed guidance and step-by-step navigation. The input is the recognized emotion, and the output is the dynamically changed user interface.

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

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

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

[0673] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

[0684] In the headset type terminal 314, a reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0685] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the headset type terminal 314 will be referred to as the "terminal."

[0686] This invention is a system called a "Program Handover Assistant" that helps new engineers quickly catch up on a project by retrieving and analyzing source code from a Git repository. A specific embodiment of the system is described below.

[0687] Specifying and cloning a repository

[0688] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[0689] The server clones the repository from the URL you entered. The server uses the Git API to download the repository to a virtual directory. Once this download is complete, the server proceeds to the next step.

[0690] Language analysis

[0691] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, and counts the number of files in each programming language.

[0692] The server then calculates the percentage of each programming language used in the repository, based on the results of the calculations, and determines the proportion of languages ​​used within the repository.

[0693] Parsing the configuration file

[0694] The server analyzes the key configuration files in the repository (e.g., package.json, requirements.txt). It parses these files and lists the libraries and modules that the project depends on.

[0695] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[0696] Information Visualization

[0697] The device displays the analysis results received from the server on the user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[0698] The device provides a graphical dashboard that allows engineers to intuitively understand the overall picture of the project, displaying heat maps and graphs.

[0699] Presenting the reading order

[0700] Based on the analysis, the server suggests the order in which the engineer should start reading files and directories. The server suggests starting with important configuration files and entry points for the project.

[0701] The terminal displays a suggested reading order in the user interface, allowing new engineers to efficiently begin understanding the code base.

[0702] Specific examples

[0703] Let's say a new engineer joins a project that's a web application that uses Python and JavaScript. The user enters the repository URL, and the server clones the repository. The server then analyzes the source code and determines that it's 60% Python and 40% JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each.

[0704] The terminal displays this information on a dashboard, and the server suggests an appropriate reading order (e.g., Django app settings file settings.py, main URL setting urls.py, React entry point index.js). Engineers can start reading the code in this order and quickly catch up on the project.

[0705] This implementation allows new engineers to efficiently understand the project from the critical parts and contribute quickly.

[0706] The processing flow will be explained below.

[0707] Step 1:

[0708] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[0709] Step 2:

[0710] The server receives the URL entered by the user and clones the repository. The server uses the Git API to download the repository to the project directory on the server. At this time, it logs the success / failure of the clone process.

[0711] Step 3:

[0712] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, identifies the language for each file, and counts the number of files in each programming language.

[0713] Step 4:

[0714] Calculate the proportion of each programming language used in the repository based on the number of files counted by the server. Express these proportions as a percentage to clarify the overall language distribution.

[0715] Step 5:

[0716] The server finds and reads key configuration files in the repository (e.g., package.json, requirements.txt), parses these files, and extracts information about the libraries and modules that the project depends on.

[0717] Step 6:

[0718] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[0719] Step 7:

[0720] The device displays the analysis results received from the server on the user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[0721] Step 8:

[0722] The terminal provides a graphical dashboard that allows users to intuitively understand the overall picture of the project, displaying heat maps and graphs.

[0723] Step 9:

[0724] Based on the analysis, the server will suggest the order in which the user should start reading the code from, starting from the files and directories. The server will recommend starting with the project's important configuration files and entry points.

[0725] Step 10:

[0726] The device will display the suggested reading order in the user interface, allowing the user to start reading the code in this order and efficiently catch up on the project.

[0727] Example 1

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

[0729] It is difficult for new engineers joining a software project to quickly understand the overall picture of the project and its detailed dependencies. With traditional methods, it takes a lot of time and effort for new engineers to quickly get up to speed on the project, which slows down the progress of the project. There is a need for a system that can efficiently understand the project's code base.

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

[0731] In this invention, the server includes a means for receiving a repository URL specified by a user and cloning the repository, a means for scanning all files in the cloned repository to identify programming languages ​​used and calculate the proportion of each language, and a means for analyzing major configuration files and extracting project dependencies, which allows new engineers to quickly grasp the overall picture and dependencies of the project and efficiently understand the code base.

[0732] "User" refers to a person who uses the system and is the entity that performs specific operations or inputs.

[0733] A "repository" is a type of database that stores software source code and version control information.

[0734] A "URL" is a string of characters that indicates the location of a resource on the Internet.

[0735] "Clone" refers to the operation of duplicating the contents of a repository to a local environment.

[0736] A "file" is a unit for storing data, and includes program code and setting information.

[0737] "Scanning" is the process of examining the entire file system and extracting specific information.

[0738] A "programming language" is a formal language for writing computer programs.

[0739] A "ratio" is a number that indicates the proportion of an individual element to the whole.

[0740] A "configuration file" is a file used to specify software behavior and dependencies.

[0741] A "dependency" refers to a relationship in which a software module depends on another module.

[0742] "Analysis" is the process of examining data or systems in detail to derive specific information.

[0743] "Visualization" is a method of displaying abstract data graphically to make it easier to understand.

[0744] "User interface" refers to the screen and operating means that allow a user to interact with a system.

[0745] A "reading order" is an order indicating the recommended reading priority for understanding software code.

[0746] This invention relates to a "program handover assistant" system. This system assists new engineers in quickly catching up with a project by retrieving and analyzing source code from a Git repository. Specific embodiments are described below.

[0747] Specifying and cloning a repository

[0748] A user accesses the system and enters the URL of the Git repository they want to take over into the web interface. After the user enters the URL, the server receives it and uses the Git API to clone the repository into a virtual directory. Specifically, the server executes "git clone https: / / github.com / example / project-url" and downloads the contents of the repository.

[0749] Language analysis

[0750] The server scans all files in the cloned repository and identifies the programming language of each file based on its extension. For example, it identifies .py files as Python and .js files as JavaScript. The server then tallies the number of files in each language and calculates their percentage of the total. This information helps engineers understand how much of each programming language is used in a project.

[0751] Parsing the configuration file

[0752] The server parses the main configuration files in the repository (e.g., package.json, requirements.txt) and generates a list of libraries and modules that the project depends on. Specifically, it extracts Django and numpy from requirements.txt, and React and axios from package.json. The server analyzes these dependencies and gathers information to create an overview of the project's architecture.

[0753] Information Visualization

[0754] The terminal displays the analysis results received from the server in a user interface. The analysis results include the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The terminal also provides a graphical dashboard, such as a heat map or pie chart, to help engineers intuitively understand the overall picture of the project.

[0755] Presenting the reading order

[0756] Based on the analysis results, the server suggests an order in which engineers should start reading files and directories. This order recommends starting with important configuration files and entry points for the project. The terminal displays the suggested reading order in a user interface, allowing new engineers to efficiently begin understanding the codebase.

[0757] Specific examples

[0758] Consider a new engineer joining a web application project that uses Python and JavaScript. The user enters the repository URL "https: / / github.com / example / project-url." The server clones the repository from this URL and determines that 60% of the code is Python and 40% is JavaScript. The server analyzes requirements.txt and package.json and lists dependencies such as Django, numpy, React, and axios, respectively. The terminal displays this information on a dashboard, using pie charts and heat maps to help the engineer intuitively understand it. The server then suggests the order in which to parse Django's settings.py, urls.py, React's index.js, etc., and the terminal displays it.

[0759] This system allows new engineers to efficiently start understanding the key parts of a project and contribute quickly.

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

[0761] Step 1:

[0762] The user accesses the system's web interface and enters the URL of the Git repository they want to take over into a text box. When the user enters the URL, it is sent to the server. Specifically, the user enters "https: / / github.com / example / project-url."

[0763] Step 2:

[0764] The server receives the URL and uses the Git API to clone the repository into a virtual directory. The command for this clone operation is "git clone https: / / github.com / example / project-url". The input is the repository URL, and the output is the contents of the cloned repository in the virtual directory.

[0765] Step 3:

[0766] The server scans all files in the cloned repository. The specific operation of identifying the programming language based on the extension of each file is, for example, identifying ".py" files as Python and ".js" files as JavaScript. The input is all files in the repository, and the output is the identification result for each programming language.

[0767] Step 4:

[0768] The server counts the number of files for each identified programming language. Specifically, it counts how many Python files there are, how many JavaScript files there are, etc. The input is the programming language identification result, and the output is the number of files for each language and their proportion.

[0769] Step 5:

[0770] The server parses key configuration files, e.g. package.json and requirements.txt, and extracts dependent libraries and modules, such as React and axios from package.json, and Django and numpy from requirements.txt. The input is the configuration files in the cloned repository, and the output is the list of extracted dependencies.

[0771] Step 6:

[0772] The server analyzes dependencies and gathers an overview of the project's architecture, including how each library and module is related. The input is a list of dependencies, and the output is an overview of the project's architecture.

[0773] Step 7:

[0774] The terminal displays the analysis results received from the server in a user interface. The displayed content includes the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. For example, a pie chart or heat map is displayed. The input is the server's analysis results, and the output is graphical information displayed on the dashboard.

[0775] Step 8:

[0776] Based on the analysis results, the server suggests the order in which the engineer should start reading from which files and directories. For example, it suggests the reading order for Django's settings.py, urls.py, React's index.js, etc. The input is the analysis results, and the output is the suggested reading order.

[0777] Step 9:

[0778] The terminal displays the suggested parsing order in a user interface, allowing new engineers to efficiently begin understanding the codebase. The input is the parsing order suggested by the server, and the output is what is displayed in the user interface.

[0779] (Application example 1)

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

[0781] When introducing new software to existing industrial machinery, it is difficult to understand the proper installation order, checking the settings and dependencies, and there are challenges that require time and effort.In addition, there is insufficient support to help new engineers quickly get up to speed on the project, making it difficult to carry out the project smoothly.

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

[0783] In this invention, the server includes means for retrieving source code from a Git repository, means for analyzing the retrieved source code and calculating the proportion of program languages, means for analyzing configuration files in the source code and extracting dependencies, means for visualizing and displaying the analysis results on a user interface, means for proposing a program interpretation order based on the analysis results, and means for installing new software on industrial machines and quickly completing the configuration, thereby enabling new software to be introduced to industrial machines quickly and efficiently and enabling new engineers to smoothly catch up on the project.

[0784] A "Git repository" is a database used in a distributed version control system to manage source code and change history.

[0785] "Source code" is the original code of a computer program written in a particular programming language.

[0786] A "programming language" is an artificial language for writing computer programs, and is a means by which humans give instructions to computers.

[0787] A "dependency" is a relationship in which a software component depends on another component to function.

[0788] A "configuration file" is a text file that describes the operating environment and operation settings of the software.

[0789] "Visualization" is the process of graphically representing data and analysis results to make them easier to understand intuitively.

[0790] A "user interface" is an interface through which humans interact with computers.

[0791] "Industrial machinery" is a general term for machinery and robots used in manufacturing and production industries.

[0792] "Installation" is the process of introducing software onto a computer system and making its functionality available.

[0793] "Configuration" is the process of preparing the parameters and environment necessary for software to perform a specific operation.

[0794] The present invention is a system for quickly and efficiently installing new software on industrial machines and completing the setup, and is implemented by the following steps.

[0795] Specifying and cloning a repository

[0796] The user enters the URL of the Git repository they want to take over through a web interface. The server clones the repository from the URL. Specifically, it uses the Git API to download the repository to a virtual directory. Once the download is complete, the server proceeds to the next step.

[0797] Language analysis

[0798] The server scans all files in the cloned repository, determines the programming language based on the file extension of each file, counts the number of files in each programming language, and then calculates the percentage of languages ​​used in the repository.

[0799] Parsing the configuration file

[0800] The server analyzes the main configuration files in the repository (e.g. requirements.txt, package.json), parses these files, lists the libraries and modules that the project depends on, analyzes the dependencies, and gathers information to get an overview of the project's architecture.

[0801] Information Visualization

[0802] The terminal displays the analysis results received from the server in a user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The terminal provides a graphical dashboard, allowing industrial machine operators to intuitively understand the overall picture of the project.

[0803] Presenting the reading order

[0804] Based on the analysis results, the server will suggest the order in which the operator should start reading files and directories, suggesting starting with important configuration files and entry points, optimizing the configuration order.

[0805] As a concrete example, suppose a new engineer joins an industrial software project that uses Python and JavaScript. The user enters the repository URL and the server clones the repository. The server then analyzes the source code and determines that 60% of the code is Python and 40% is JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each. The terminal displays this information on a dashboard, and the server also suggests an appropriate reading order. The operator can start reading the code in this order and quickly catch up on the project.

[0806] An example prompt for a generative AI model might look like this:

[0807] "What is the best procedure for installing and configuring new software on an industrial machine? Considering the code's language mix and dependencies."

[0808] "Analyze a Git repository and automatically generate software setup instructions for an industrial machine. Determine the order based on configuration files and key modules."

[0809] This embodiment allows for the rapid and efficient introduction of new software to industrial machines, allowing new engineers to smoothly get up to speed on projects.

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

[0811] Step 1:

[0812] The user enters the URL of the Git repository they want to take over via a web interface, which provides the Git repository URL as input and sends it to the server.

[0813] Step 2:

[0814] The server clones the repository from the URL entered using the Git API. The clone process downloads the repository's source code into a virtual directory. As output, a copy of the source code is created in the local directory.

[0815] Step 3:

[0816] The server scans all files in the virtual directory and determines the programming language based on the file extension. The input is the source code files in the virtual directory, and the output is a count of the number of files in each programming language.

[0817] Step 4:

[0818] The server calculates the percentage of each programming language based on the results of the aggregation. The number of files per extension obtained in step 3 is used as input, and the percentage of each programming language is calculated as output.

[0819] Step 5:

[0820] The server parses important configuration files (e.g. requirements.txt, package.json) and extracts dependencies. It takes the contents of the configuration files as input and generates a list of dependencies as output.

[0821] Step 6:

[0822] The server further analyzes the dependencies to get an overview of the project's architecture, specifically the dependencies between the main modules and the configuration parameters, using the information in the configuration files as input and providing information about the project's architecture as output.

[0823] Step 7:

[0824] The server sends the analysis results to the terminal, which displays them on a user interface. The terminal receives the analysis results as input and displays them in a graphical dashboard as output. The dashboard includes the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[0825] Step 8:

[0826] The server proposes a file or directory parsing order based on the parsing results. It uses the parsing results as input and generates an appropriate parsing order as output.

[0827] Step 9:

[0828] The terminal displays the suggested deciphering sequence in a user interface to enable the operator to efficiently understand the code. The suggested deciphering sequence is provided to the terminal as input and displayed in the user interface as output.

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

[0830] This invention is a system called a "Program Handover Assistant" that retrieves source code from a Git repository and analyzes it to help new engineers quickly get up to speed on a project. Furthermore, by combining it with an emotion engine that recognizes user emotions, the user experience can be improved. A specific embodiment of the system is described below.

[0831] Specifying and cloning a repository

[0832] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[0833] The server clones the repository from the URL you entered. The server uses the Git API to download the repository to a project directory on the server. Once this download is complete, the server proceeds to the next step.

[0834] Language analysis

[0835] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, and counts the number of files in each programming language.

[0836] The server then calculates the percentage of each programming language used in the repository, based on the results of the calculations, and determines the proportion of languages ​​used within the repository.

[0837] Parsing the configuration file

[0838] The server analyzes the key configuration files in the repository (e.g., package.json, requirements.txt). It parses these files and lists the libraries and modules that the project depends on.

[0839] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[0840] Information Visualization

[0841] The device displays the analysis results received from the server on the user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[0842] The device provides a graphical dashboard that allows engineers to intuitively understand the overall picture of the project, displaying heat maps and graphs.

[0843] Presenting the reading order

[0844] Based on the analysis, the server will suggest the order in which the engineer should start reading files and directories. The server will suggest starting with the project's important configuration files and entry points.

[0845] The terminal will display a suggested reading order in the user interface, allowing the engineer to start reading the code in this order and efficiently catch up on the project.

[0846] Emotion engine integration

[0847] The emotion engine analyzes the user's facial expressions and voice to recognize emotions in real time. The user's emotional data is collected and analyzed through the camera and microphone.

[0848] The server receives the analysis results of the emotion engine and dynamically changes the content and presentation of the user interface. For example, if the user is feeling stressed, the server will provide more considerate explanations and guidance.

[0849] Specific examples

[0850] Let's say a new engineer joins a project that's a web application that uses Python and JavaScript. The user enters the repository URL, and the server clones the repository. The server then analyzes the source code and determines that it's 60% Python and 40% JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each.

[0851] The terminal displays this information on a dashboard, and the server suggests an appropriate reading order (e.g., Django app settings file settings.py, main URL setting urls.py, React entry point index.js). Engineers can start reading the code in this order and quickly catch up on the project.

[0852] Furthermore, the emotion engine analyzes the user's facial expressions and voice in real time, and if the user is confused, the server adjusts the user interface to provide more detailed guidance and support, such as step-by-step navigation and demonstrations to help the user learn.

[0853] This embodiment allows new engineers to efficiently understand the project from the important parts and contribute quickly, and the emotion engine provides appropriate support according to the user's state, improving learning efficiency.

[0854] The processing flow will be explained below.

[0855] Step 1:

[0856] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[0857] Step 2:

[0858] The server receives the URL entered by the user and clones the repository. The server uses the Git API to download the repository to the project directory on the server. At this time, it logs the success / failure of the clone process.

[0859] Step 3:

[0860] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, identifies the language for each file, and counts the number of files in each programming language.

[0861] Step 4:

[0862] Calculate the proportion of each programming language used in the repository based on the number of files counted by the server. Express these proportions as a percentage to clarify the overall language distribution.

[0863] Step 5:

[0864] The server finds and reads key configuration files in the repository (e.g., package.json, requirements.txt), parses these files, and extracts information about the libraries and modules that the project depends on.

[0865] Step 6:

[0866] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[0867] Step 7:

[0868] The terminal displays the analysis results received from the server in a user interface. The analysis results include the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The user interface is displayed in a visually easy-to-understand format.

[0869] Step 8:

[0870] The terminal provides a graphical dashboard that gives users an intuitive overview of the project, displaying heat maps and graphs that users can use to gain a better understanding of key codebases.

[0871] Step 9:

[0872] Based on the analysis, the server will suggest the order in which the user should start reading the code from, starting with the project's important configuration files and entry point files.

[0873] Step 10:

[0874] The terminal will display the suggested reading order on the user interface, allowing the user to start reading the code in this order and catch up on the project efficiently, thereby saving time and effort.

[0875] Step 11:

[0876] The emotion engine analyzes the user's facial expressions and voice in real time to recognize their emotions. It also collects emotional data through the camera and microphone to detect when the user is confused or stressed.

[0877] Step 12:

[0878] The server receives the analysis results of the emotion engine and dynamically changes the content and presentation of the user interface. For example, if the user is confused, it can provide more detailed guidance or step-by-step navigation, or display encouraging messages to motivate the user.

[0879] Step 13:

[0880] The device reflects the feedback from the emotion engine and provides the optimal user interface for the user, allowing the user to use the system comfortably and effectively progress with their learning and work.

[0881] Example 2

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

[0883] Traditionally, new engineers have struggled to quickly get up to speed on projects. These challenges include the difficulty of understanding the languages ​​and dependencies used within the repository, the time it takes to read code in an inappropriate order, and the lack of a way to recognize user emotions and improve learning efficiency. A new system is needed to address these challenges.

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

[0885] In this invention, the server includes means for retrieving source code from a Git repository, means for analyzing the retrieved source code to calculate the proportion of programming languages, means for analyzing configuration files in the source code to extract dependencies, means for visualizing the analysis results and displaying them in a user interface, means for proposing a program interpretation order based on the analysis results, means for recognizing and analyzing user emotions, and means for dynamically changing the content and presentation method of the user interface based on the emotion analysis results. This allows new engineers to efficiently catch up on projects and improves learning efficiency by providing appropriate support based on user emotions.

[0886] "Source code" is the text data of a program that defines the behavior of software.

[0887] A "Git repository" is a database used to manage source code and its change history in the Git version control system.

[0888] "Means" are specific technical means such as methods or devices for achieving a specific purpose.

[0889] "Analysis" is the process of breaking down information and clarifying its components and relationships.

[0890] A "programming language" is a set of rules and notations for creating programs that are executed by a computer.

[0891] "User interface" refers to the means or methods for inputting and outputting information between a user and a system.

[0892] A "dependency" is a relationship in which a piece of software depends on other specific software or libraries to function.

[0893] An "emotion engine" refers to an algorithm or device for recognizing and analyzing a user's emotions.

[0894] "Dynamic change" refers to changing content or settings in real time depending on the situation.

[0895] A "reading order" is the recommended order in which to begin reading a program or document in order to understand its contents in the proper order.

[0896] This invention is a system called "Program Handover Assistant" that retrieves source code from a Git repository and analyzes it to help new engineers quickly get up to speed on a project. Furthermore, by integrating an emotion engine that recognizes user emotions, the user experience can be improved. A specific embodiment of the system is described in detail below.

[0897] Specifying and cloning a repository

[0898] A user accesses the system and enters the URL of the Git repository they want to transfer. This is done through a web interface. The server clones the repository from the URL using the Git API and downloads it to the project directory on the server.

[0899] Language analysis

[0900] The server scans all files in the cloned repository, identifies the programming language based on the file extension, counts the number of files in each programming language, and calculates the percentage of each programming language used in the repository.

[0901] Parsing the configuration file

[0902] The server analyzes the main configuration files in the repository (e.g. package.json, requirements.txt). It parses these files to list the libraries and modules that the project depends on. It then analyzes the dependencies and gets an overview of the project's architecture.

[0903] Information Visualization

[0904] The terminal displays the analysis results received from the server on a user interface. The analysis results include the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The terminal also provides a graphical dashboard that allows engineers to intuitively understand the overall picture of the project. The dashboard displays heat maps and graphs.

[0905] Presenting the reading order

[0906] Based on the analysis results, the server will suggest to the engineer the appropriate order in which to read files and directories, allowing the engineer to start reading from important configuration files and entry points, and efficiently catch up on the project.

[0907] Emotion engine integration

[0908] The emotion engine analyzes the user's facial expressions and voice to recognize emotions in real time. It collects and analyzes the user's emotional data through a camera and microphone. The server dynamically changes the content and presentation of the user interface based on the emotion engine's analysis results. For example, if the user is feeling stressed, it will provide more considerate explanations and guidance.

[0909] Specific examples

[0910] Let's say a new engineer joins a project that's a web application that uses Python and JavaScript. The user enters the repository URL, and the server clones the repository. The server then analyzes the source code and determines that it's 60% Python and 40% JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each.

[0911] The terminal displays this information on a dashboard, and the server suggests an appropriate reading order (e.g., Django app settings file settings.py, main URL setting urls.py, React entry point index.js). Engineers can start reading the code in this order and quickly catch up on the project.

[0912] Furthermore, the emotion engine analyzes the user's facial expressions and voice in real time, and if the user is confused, the server adjusts the user interface to provide more detailed guidance and support, such as step-by-step navigation and demonstrations to help the user learn.

[0913] Prompt Sentence Examples

[0914] Describe a system that helps engineers joining a new project understand the project efficiently. This system retrieves source code from a Git repository, displays the analysis results on a dashboard, and suggests an appropriate reading order. It also includes a function that uses an emotion engine to recognize user emotions in real time and provide appropriate guidance. As a concrete example, imagine a web application project using Python and JavaScript.

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

[0916] Step 1:

[0917] Specifying and cloning a repository

[0918] A user accesses the system and enters the URL of the Git repository they want to take over, which is then entered into a text box on the web interface.

[0919] The server takes the input URL and clones the specified repository using the Git API. This operation downloads the entire contents of the repository into a project directory on the server. The input is the Git repository URL, and the output is the downloaded repository files.

[0920] Step 2:

[0921] Language analysis

[0922] The server scans all files in the downloaded repository, and this scanning is done using the file system API.

[0923] The server checks the extension of each file and determines the programming language based on that. For example, if the extension is ".py", it is determined to be Python, and if it is ".js", it is determined to be JavaScript.

[0924] The server counts the number of files in each identified programming language and calculates the percentage of the repository that each programming language occupies. The input is the file extension, and the output is the usage rate of each programming language.

[0925] Step 3:

[0926] Parsing the configuration file

[0927] The server identifies key configuration files in the repository (e.g., package.json, requirements.txt) and loads them.

[0928] The server parses the contents of the configuration file and lists the libraries and modules that the project depends on, using a JSON parser or text analysis tool.

[0929] The server analyzes dependencies and understands the relationships between major modules. The input is a configuration file, and the output is a list of dependent libraries and modules.

[0930] Step 4:

[0931] Information Visualization

[0932] The server generates and sends the analysis results to the device, which include the percentage of programming languages ​​used, a list of dependent libraries, and a summary of the project's architecture.

[0933] A graphical dashboard is provided based on the analysis results received by the device. This dashboard displays heat maps and various graphs. The input is the analysis result data, and the output is the displayed dashboard.

[0934] Step 5:

[0935] Presenting the reading order

[0936] Based on the analysis, the server recommends the order in which the engineer should start reading from, prioritizing important configuration files and entry points.

[0937] The terminal displays the recommended parsing order in the user interface, and the engineer can start reading the code according to this order. The input is the parsing result, and the output is the recommended parsing order.

[0938] Step 6:

[0939] Emotion engine integration

[0940] The emotion engine analyzes the user's facial expressions and voice in real time to recognize their emotional state, using data collected through the camera and microphone.

[0941] The server receives the analysis results of the emotion engine and dynamically changes the content and presentation of the user interface depending on the user's stress level or confusion, for example, by providing more detailed guidance or step-by-step explanations. The input is emotion data, and the output is an adjusted user interface.

[0942] This allows new engineers to efficiently understand the project from the key parts in the repository and quickly catch up, and the emotion engine provides appropriate support.

[0943] (Application example 2)

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

[0945] With the advancement of information technology, it has become common for many companies and organizations to use multiple programming languages ​​and libraries in software development projects. However, when new engineers join a project, it is difficult for them to understand the code base and dependencies within the project and quickly catch up. Furthermore, maintaining factory robots requires an understanding of complex systems, making it difficult for new engineers to work efficiently in a short period of time. In addition, stress and confusion can cause a significant drop in work efficiency. An effective method to solve these problems is needed.

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

[0947] In this invention, the server includes means for retrieving source code from a Git repository, means for analyzing the retrieved source code and calculating the proportion of programming languages, means for analyzing configuration files in the source code and extracting dependencies, means for visualizing the analysis results and displaying them in a user interface, means for proposing a program interpretation order based on the analysis results, means for recognizing emotions by analyzing a user's facial expressions and voice, and means for dynamically changing the content and presentation method of the user interface based on the emotion recognition results. This not only enables new engineers to quickly catch up on projects and factory robot systems and work efficiently, but also enables optimal support to be provided according to the user's emotional state.

[0948] A "Git repository" is a database for version control in software development, which tracks the change history of source code and allows multiple developers to work together.

[0949] "Source code" means computer program instructions written in a programming language in a form that can be understood and executed by a computer.

[0950] "Programming language proportion" is a metric that indicates the usage rate of various programming languages ​​used within a particular project or repository, and represents the proportion of each language in the total.

[0951] A "configuration file" is a file that describes various settings and dependencies in a software project, and specifically includes version information for libraries and modules.

[0952] A "dependency" refers to a relationship in which one software component or module depends on another component or module, such that one component requires the other component to function correctly.

[0953] "Visualization" refers to the visual representation of data or information, which makes it easier for users to intuitively understand the information.

[0954] A "user interface" is an interface that allows a user to interact with a computer system, and is operated using a graphical display and input device.

[0955] A "reading order" is the order in which a new engineer should read through the files and directories to understand the source code of a project.

[0956] "Facial expressions" are expressions on a human face that change to show emotions and intentions.

[0957] "Speech" refers to the sound produced by the human voice and is used to convey various information, including emotions and intentions.

[0958] "Emotion recognition" is a technology that analyzes a user's facial expressions and voice to estimate their emotional state at that time.

[0959] "Dynamic change" means that the system automatically changes its content and behavior in real time according to the situation, thereby providing users with the most appropriate information and operating methods.

[0960] This invention provides a "Robot Maintenance Assistant" that streamlines factory robot maintenance and helps new engineers quickly understand the system. Specific embodiments of this system are described below.

[0961] 1. Server Processing

[0962] The server receives the URL of the Git repository specified by the user. Based on the URL entered by the user, the server uses the Git API to clone the repository and save it to a local directory. The server then analyzes the saved source code to determine the proportion of programming languages ​​used and dependencies. To analyze dependencies, it parses the main configuration files in the repository (e.g., package.json and requirements.txt).

[0963] 2. Information visualization

[0964] The results of the analysis by the server are displayed on a graphical dashboard. Information such as the proportion of various programming languages, an overview of dependencies, and the main architecture is visually displayed, allowing engineers to intuitively understand it. For this purpose, the dashboard library is used.

[0965] 3. Suggested reading order

[0966] Based on the analysis results, the server will suggest which files and directories the engineer should start reading from, especially important configuration files and entry point files, allowing the engineer to catch up efficiently.

[0967] 4. Emotion recognition

[0968] The server is equipped with an emotion engine (e.g., the emotion_recognition library) that analyzes the user's facial expressions and voice in real time and recognizes their emotions. Emotional data is collected through a camera and microphone, and the content and presentation of the interface are dynamically changed if the user is feeling stressed or confused. Specifically, it provides more detailed guidance and step-by-step navigation.

[0969] 5. Specific Examples

[0970] Imagine a new maintenance engineer at a factory needs to quickly understand a Git repository for control software for a new industrial robot. The user enters the repository URL, and the server clones and analyzes it. The analysis results are displayed on a dashboard, showing the proportion of programming languages ​​and dependencies at a glance. An emotion engine monitors the user's facial expressions and voice, and if stress or confusion is detected, it provides detailed instructions and guidance.

[0971] Prompt Sentence Examples

[0972] You are designing an assistant to help factory maintenance engineers quickly understand the Git repository for a new robotics system. The system will clone and analyze the repository, visualize the results, and dynamically adjust the interface based on emotion recognition. Write the code to implement this system using Python.

[0973] In this way, the invention not only helps new engineers quickly get up to speed on projects, but also creates a system that provides optimal support depending on the emotions that arise during the process.

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

[0975] Step 1:

[0976] The user accesses the system's web interface and enters the URL of the Git repository they want to take over, which is then sent to the server.

[0977] Step 2:

[0978] The server receives the URL of the Git repository and clones it using the Git API. At this time, the source code of the cloned repository is downloaded to a local directory. The input is the repository URL, and the output is the source code saved in the local directory.

[0979] Step 3:

[0980] The server scans the source code stored in the local directory and determines the programming language used based on the file extension of each file. It then counts the number of files for each identified programming language and calculates the percentage of each language in the total. The input is the source code, and the output is the percentage of programming languages.

[0981] Step 4:

[0982] The server parses the main configuration files in the repository (e.g., package.json, requirements.txt) and extracts dependencies. It parses each configuration file and lists the libraries and modules that the project depends on. The input is the configuration file, and the output is the list of dependencies.

[0983] Step 5:

[0984] The server processes the percentage of programming languages ​​and the list of dependencies into data for display on a graphical dashboard and sends it to the terminal. The input is the percentage of programming languages ​​and the list of dependencies, and the output is the data for displaying on the dashboard.

[0985] Step 6:

[0986] The terminal receives the data sent from the server and displays the analysis results on a graphical dashboard. The percentage of languages ​​used, a list of dependencies, and an overview of the architecture are visually displayed. The input is the data to be displayed on the dashboard, and the output is the displayed dashboard.

[0987] Step 7:

[0988] Based on the analysis, the server suggests an order in which the engineer should start reading files and directories, recommending that they start with the main configuration file or entry point. The input is the analysis results, and the output is the suggested parsing order.

[0989] Step 8:

[0990] The terminal displays the parsing order received from the server on the user interface. The engineer can start reading the code according to this order. The input is the parsing order, and the output is the order displayed on the user interface.

[0991] Step 9:

[0992] The server uses an emotion engine to analyze the user's facial expressions and voice in real time to recognize emotions. Emotion data is collected through the camera and microphone and analyzed. The input is data from the camera and microphone, and the output is the recognized emotion.

[0993] Step 10:

[0994] The server dynamically changes the content and presentation of the user interface based on the emotion recognition results. If the user is feeling stressed, it provides detailed guidance and step-by-step navigation. The input is the recognized emotion, and the output is the dynamically changed user interface.

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

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

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

[0998] [Fourth embodiment]

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

[1000] 7, a data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

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

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

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

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

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

[1006] The control object 443 includes a display device, LEDs in the eyes, and motors for driving the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

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

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

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

[1010] In the robot 414, the processor 46 performs the reception output process. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

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

[1012] This invention is a system called a "Program Handover Assistant" that helps new engineers quickly catch up on a project by retrieving and analyzing source code from a Git repository. A specific embodiment of the system is described below.

[1013] Specifying and cloning a repository

[1014] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[1015] The server clones the repository from the URL you entered. The server uses the Git API to download the repository to a virtual directory. Once this download is complete, the server proceeds to the next step.

[1016] Language analysis

[1017] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, and counts the number of files in each programming language.

[1018] The server then calculates the percentage of each programming language used in the repository, based on the results of the calculations, and determines the proportion of languages ​​used within the repository.

[1019] Parsing the configuration file

[1020] The server analyzes the key configuration files in the repository (e.g., package.json, requirements.txt). It parses these files and lists the libraries and modules that the project depends on.

[1021] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[1022] Information Visualization

[1023] The device displays the analysis results received from the server on the user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[1024] The device provides a graphical dashboard that allows engineers to intuitively understand the overall picture of the project, displaying heat maps and graphs.

[1025] Presenting the reading order

[1026] Based on the analysis, the server suggests the order in which the engineer should start reading files and directories. The server suggests starting with important configuration files and entry points for the project.

[1027] The terminal displays a suggested reading order in the user interface, allowing new engineers to efficiently begin understanding the code base.

[1028] Specific examples

[1029] Let's say a new engineer joins a project that's a web application that uses Python and JavaScript. The user enters the repository URL, and the server clones the repository. The server then analyzes the source code and determines that it's 60% Python and 40% JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each.

[1030] The terminal displays this information on a dashboard, and the server suggests an appropriate reading order (e.g., Django app settings file settings.py, main URL setting urls.py, React entry point index.js). Engineers can start reading the code in this order and quickly catch up on the project.

[1031] This implementation allows new engineers to efficiently understand the project from the critical parts and contribute quickly.

[1032] The processing flow will be explained below.

[1033] Step 1:

[1034] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[1035] Step 2:

[1036] The server receives the URL entered by the user and clones the repository. The server uses the Git API to download the repository to the project directory on the server. At this time, it logs the success / failure of the clone process.

[1037] Step 3:

[1038] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, identifies the language for each file, and counts the number of files in each programming language.

[1039] Step 4:

[1040] Calculate the proportion of each programming language used in the repository based on the number of files counted by the server. Express these proportions as a percentage to clarify the overall language distribution.

[1041] Step 5:

[1042] The server finds and reads key configuration files in the repository (e.g., package.json, requirements.txt), parses these files, and extracts information about the libraries and modules that the project depends on.

[1043] Step 6:

[1044] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[1045] Step 7:

[1046] The device displays the analysis results received from the server on the user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[1047] Step 8:

[1048] The terminal provides a graphical dashboard that allows users to intuitively understand the overall picture of the project, displaying heat maps and graphs.

[1049] Step 9:

[1050] Based on the analysis, the server will suggest the order in which the user should start reading the code from, starting from the files and directories. The server will recommend starting with the project's important configuration files and entry points.

[1051] Step 10:

[1052] The device will display the suggested reading order in the user interface, allowing the user to start reading the code in this order and efficiently catch up on the project.

[1053] Example 1

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

[1055] It is difficult for new engineers joining a software project to quickly understand the overall picture of the project and its detailed dependencies. With traditional methods, it takes a lot of time and effort for new engineers to quickly get up to speed on the project, which slows down the progress of the project. There is a need for a system that can efficiently understand the project's code base.

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

[1057] In this invention, the server includes a means for receiving a repository URL specified by a user and cloning the repository, a means for scanning all files in the cloned repository to identify programming languages ​​used and calculate the proportion of each language, and a means for analyzing major configuration files and extracting project dependencies, which allows new engineers to quickly grasp the overall picture and dependencies of the project and efficiently understand the code base.

[1058] "User" refers to a person who uses the system and is the entity that performs specific operations or inputs.

[1059] A "repository" is a type of database that stores software source code and version control information.

[1060] A "URL" is a string of characters that indicates the location of a resource on the Internet.

[1061] "Clone" refers to the operation of duplicating the contents of a repository to a local environment.

[1062] A "file" is a unit for storing data, and includes program code and setting information.

[1063] "Scanning" is the process of examining the entire file system and extracting specific information.

[1064] A "programming language" is a formal language for writing computer programs.

[1065] A "ratio" is a number that indicates the proportion of an individual element to the whole.

[1066] A "configuration file" is a file used to specify software behavior and dependencies.

[1067] A "dependency" refers to a relationship in which a software module depends on another module.

[1068] "Analysis" is the process of examining data or systems in detail to derive specific information.

[1069] "Visualization" is a method of displaying abstract data graphically to make it easier to understand.

[1070] "User interface" refers to the screen and operating means that allow a user to interact with a system.

[1071] A "reading order" is an order indicating the recommended reading priority for understanding software code.

[1072] This invention relates to a "program handover assistant" system. This system assists new engineers in quickly catching up with a project by retrieving and analyzing source code from a Git repository. Specific embodiments are described below.

[1073] Specifying and cloning a repository

[1074] A user accesses the system and enters the URL of the Git repository they want to take over into the web interface. After the user enters the URL, the server receives it and uses the Git API to clone the repository into a virtual directory. Specifically, the server executes "git clone https: / / github.com / example / project-url" and downloads the contents of the repository.

[1075] Language analysis

[1076] The server scans all files in the cloned repository and identifies the programming language of each file based on its extension. For example, it identifies .py files as Python and .js files as JavaScript. The server then tallies the number of files in each language and calculates their percentage of the total. This information helps engineers understand how much of each programming language is used in a project.

[1077] Parsing the configuration file

[1078] The server parses the main configuration files in the repository (e.g., package.json, requirements.txt) and generates a list of libraries and modules that the project depends on. Specifically, it extracts Django and numpy from requirements.txt, and React and axios from package.json. The server analyzes these dependencies and gathers information to create an overview of the project's architecture.

[1079] Information Visualization

[1080] The terminal displays the analysis results received from the server in a user interface. The analysis results include the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The terminal also provides a graphical dashboard, such as a heat map or pie chart, to help engineers intuitively understand the overall picture of the project.

[1081] Presenting the reading order

[1082] Based on the analysis results, the server suggests an order in which engineers should start reading files and directories. This order recommends starting with important configuration files and entry points for the project. The terminal displays the suggested reading order in a user interface, allowing new engineers to efficiently begin understanding the codebase.

[1083] Specific examples

[1084] Consider a new engineer joining a web application project that uses Python and JavaScript. The user enters the repository URL "https: / / github.com / example / project-url." The server clones the repository from this URL and determines that 60% of the code is Python and 40% is JavaScript. The server analyzes requirements.txt and package.json and lists dependencies such as Django, numpy, React, and axios, respectively. The terminal displays this information on a dashboard, using pie charts and heat maps to help the engineer intuitively understand it. The server then suggests the order in which to parse Django's settings.py, urls.py, React's index.js, etc., and the terminal displays it.

[1085] This system allows new engineers to efficiently start understanding the key parts of a project and contribute quickly.

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

[1087] Step 1:

[1088] The user accesses the system's web interface and enters the URL of the Git repository they want to take over into a text box. When the user enters the URL, it is sent to the server. Specifically, the user enters "https: / / github.com / example / project-url."

[1089] Step 2:

[1090] The server receives the URL and uses the Git API to clone the repository into a virtual directory. The command for this clone operation is "git clone https: / / github.com / example / project-url". The input is the repository URL, and the output is the contents of the cloned repository in the virtual directory.

[1091] Step 3:

[1092] The server scans all files in the cloned repository. The specific operation of identifying the programming language based on the extension of each file is, for example, identifying ".py" files as Python and ".js" files as JavaScript. The input is all files in the repository, and the output is the identification result for each programming language.

[1093] Step 4:

[1094] The server counts the number of files for each identified programming language. Specifically, it counts how many Python files there are, how many JavaScript files there are, etc. The input is the programming language identification result, and the output is the number of files for each language and their proportion.

[1095] Step 5:

[1096] The server parses key configuration files, e.g. package.json and requirements.txt, and extracts dependent libraries and modules, such as React and axios from package.json, and Django and numpy from requirements.txt. The input is the configuration files in the cloned repository, and the output is the list of extracted dependencies.

[1097] Step 6:

[1098] The server analyzes dependencies and gathers an overview of the project's architecture, including how each library and module is related. The input is a list of dependencies, and the output is an overview of the project's architecture.

[1099] Step 7:

[1100] The terminal displays the analysis results received from the server in a user interface. The displayed content includes the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. For example, a pie chart or heat map is displayed. The input is the server's analysis results, and the output is graphical information displayed on the dashboard.

[1101] Step 8:

[1102] Based on the analysis results, the server suggests the order in which the engineer should start reading from which files and directories. For example, it suggests the reading order for Django's settings.py, urls.py, React's index.js, etc. The input is the analysis results, and the output is the suggested reading order.

[1103] Step 9:

[1104] The terminal displays the suggested parsing order in a user interface, allowing new engineers to efficiently begin understanding the codebase. The input is the parsing order suggested by the server, and the output is what is displayed in the user interface.

[1105] (Application example 1)

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

[1107] When introducing new software to existing industrial machinery, it is difficult to understand the proper installation order, checking the settings and dependencies, and there are challenges that require time and effort.In addition, there is insufficient support to help new engineers quickly get up to speed on the project, making it difficult to carry out the project smoothly.

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

[1109] In this invention, the server includes means for retrieving source code from a Git repository, means for analyzing the retrieved source code and calculating the proportion of program languages, means for analyzing configuration files in the source code and extracting dependencies, means for visualizing and displaying the analysis results on a user interface, means for proposing a program interpretation order based on the analysis results, and means for installing new software on industrial machines and quickly completing the configuration, thereby enabling new software to be introduced to industrial machines quickly and efficiently and enabling new engineers to smoothly catch up on the project.

[1110] A "Git repository" is a database used in a distributed version control system to manage source code and change history.

[1111] "Source code" is the original code of a computer program written in a particular programming language.

[1112] A "programming language" is an artificial language for writing computer programs, and is a means by which humans give instructions to computers.

[1113] A "dependency" is a relationship in which a software component depends on another component to function.

[1114] A "configuration file" is a text file that describes the operating environment and operation settings of the software.

[1115] "Visualization" is the process of graphically representing data and analysis results to make them easier to understand intuitively.

[1116] A "user interface" is an interface through which humans interact with computers.

[1117] "Industrial machinery" is a general term for machinery and robots used in manufacturing and production industries.

[1118] "Installation" is the process of introducing software onto a computer system and making its functionality available.

[1119] "Configuration" is the process of preparing the parameters and environment necessary for software to perform a specific operation.

[1120] The present invention is a system for quickly and efficiently installing new software on industrial machines and completing the setup, and is implemented by the following steps.

[1121] Specifying and cloning a repository

[1122] The user enters the URL of the Git repository they want to take over through a web interface. The server clones the repository from the URL. Specifically, it uses the Git API to download the repository to a virtual directory. Once the download is complete, the server proceeds to the next step.

[1123] Language analysis

[1124] The server scans all files in the cloned repository, determines the programming language based on the file extension of each file, counts the number of files in each programming language, and then calculates the percentage of languages ​​used in the repository.

[1125] Parsing the configuration file

[1126] The server analyzes the main configuration files in the repository (e.g. requirements.txt, package.json), parses these files, lists the libraries and modules that the project depends on, analyzes the dependencies, and gathers information to get an overview of the project's architecture.

[1127] Information Visualization

[1128] The terminal displays the analysis results received from the server in a user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The terminal provides a graphical dashboard, allowing industrial machine operators to intuitively understand the overall picture of the project.

[1129] Presenting the reading order

[1130] Based on the analysis results, the server will suggest the order in which the operator should start reading files and directories, suggesting starting with important configuration files and entry points, optimizing the configuration order.

[1131] As a concrete example, suppose a new engineer joins an industrial software project that uses Python and JavaScript. The user enters the repository URL and the server clones the repository. The server then analyzes the source code and determines that 60% of the code is Python and 40% is JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each. The terminal displays this information on a dashboard, and the server also suggests an appropriate reading order. The operator can start reading the code in this order and quickly catch up on the project.

[1132] An example prompt for a generative AI model might look like this:

[1133] "What is the best procedure for installing and configuring new software on an industrial machine? Considering the code's language mix and dependencies."

[1134] "Analyze a Git repository and automatically generate software setup instructions for an industrial machine. Determine the order based on configuration files and key modules."

[1135] This embodiment allows for the rapid and efficient introduction of new software to industrial machines, allowing new engineers to smoothly get up to speed on projects.

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

[1137] Step 1:

[1138] The user enters the URL of the Git repository they want to take over via a web interface, which provides the Git repository URL as input and sends it to the server.

[1139] Step 2:

[1140] The server clones the repository from the URL entered using the Git API. The clone process downloads the repository's source code into a virtual directory. As output, a copy of the source code is created in the local directory.

[1141] Step 3:

[1142] The server scans all files in the virtual directory and determines the programming language based on the file extension. The input is the source code files in the virtual directory, and the output is a count of the number of files in each programming language.

[1143] Step 4:

[1144] The server calculates the percentage of each programming language based on the results of the aggregation. The number of files per extension obtained in step 3 is used as input, and the percentage of each programming language is calculated as output.

[1145] Step 5:

[1146] The server parses important configuration files (e.g. requirements.txt, package.json) and extracts dependencies. It takes the contents of the configuration files as input and generates a list of dependencies as output.

[1147] Step 6:

[1148] The server further analyzes the dependencies to get an overview of the project's architecture, specifically the dependencies between the main modules and the configuration parameters, using the information in the configuration files as input and providing information about the project's architecture as output.

[1149] Step 7:

[1150] The server sends the analysis results to the terminal, which displays them on a user interface. The terminal receives the analysis results as input and displays them in a graphical dashboard as output. The dashboard includes the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[1151] Step 8:

[1152] The server proposes a file or directory parsing order based on the parsing results. It uses the parsing results as input and generates an appropriate parsing order as output.

[1153] Step 9:

[1154] The terminal displays the suggested deciphering sequence in a user interface to enable the operator to efficiently understand the code. The suggested deciphering sequence is provided to the terminal as input and displayed in the user interface as output.

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

[1156] This invention is a system called a "Program Handover Assistant" that retrieves source code from a Git repository and analyzes it to help new engineers quickly get up to speed on a project. Furthermore, by combining it with an emotion engine that recognizes user emotions, the user experience can be improved. A specific embodiment of the system is described below.

[1157] Specifying and cloning a repository

[1158] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[1159] The server clones the repository from the URL you entered. The server uses the Git API to download the repository to a project directory on the server. Once this download is complete, the server proceeds to the next step.

[1160] Language analysis

[1161] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, and counts the number of files in each programming language.

[1162] The server then calculates the percentage of each programming language used in the repository, based on the results of the calculations, and determines the proportion of languages ​​used within the repository.

[1163] Parsing the configuration file

[1164] The server analyzes the key configuration files in the repository (e.g., package.json, requirements.txt). It parses these files and lists the libraries and modules that the project depends on.

[1165] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[1166] Information Visualization

[1167] The device displays the analysis results received from the server on the user interface, including the percentage of languages ​​used, a list of dependencies, and an overview of the architecture.

[1168] The device provides a graphical dashboard that allows engineers to intuitively understand the overall picture of the project, displaying heat maps and graphs.

[1169] Presenting the reading order

[1170] Based on the analysis, the server will suggest the order in which the engineer should start reading files and directories. The server will suggest starting with the project's important configuration files and entry points.

[1171] The terminal will display a suggested reading order in the user interface, allowing the engineer to start reading the code in this order and efficiently catch up on the project.

[1172] Emotion engine integration

[1173] The emotion engine analyzes the user's facial expressions and voice to recognize emotions in real time. The user's emotional data is collected and analyzed through the camera and microphone.

[1174] The server receives the analysis results of the emotion engine and dynamically changes the content and presentation of the user interface. For example, if the user is feeling stressed, the server will provide more considerate explanations and guidance.

[1175] Specific examples

[1176] Let's say a new engineer joins a project that's a web application that uses Python and JavaScript. The user enters the repository URL, and the server clones the repository. The server then analyzes the source code and determines that it's 60% Python and 40% JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each.

[1177] The terminal displays this information on a dashboard, and the server suggests an appropriate reading order (e.g., Django app settings file settings.py, main URL setting urls.py, React entry point index.js). Engineers can start reading the code in this order and quickly catch up on the project.

[1178] Furthermore, the emotion engine analyzes the user's facial expressions and voice in real time, and if the user is confused, the server adjusts the user interface to provide more detailed guidance and support, such as step-by-step navigation and demonstrations to help the user learn.

[1179] This embodiment allows new engineers to efficiently understand the project from the important parts and contribute quickly, and the emotion engine provides appropriate support according to the user's state, improving learning efficiency.

[1180] The processing flow will be explained below.

[1181] Step 1:

[1182] A user accesses the system and enters the URL of the Git repository they want to take over. This is done through a web interface.

[1183] Step 2:

[1184] The server receives the URL entered by the user and clones the repository. The server uses the Git API to download the repository to the project directory on the server. At this time, it logs the success / failure of the clone process.

[1185] Step 3:

[1186] The server scans all files in the cloned repository, determines the programming language of each file based on its extension, identifies the language for each file, and counts the number of files in each programming language.

[1187] Step 4:

[1188] Calculate the proportion of each programming language used in the repository based on the number of files counted by the server. Express these proportions as a percentage to clarify the overall language distribution.

[1189] Step 5:

[1190] The server finds and reads key configuration files in the repository (e.g., package.json, requirements.txt), parses these files, and extracts information about the libraries and modules that the project depends on.

[1191] Step 6:

[1192] The server analyzes dependencies and collects information to get an overview of the project's architecture, including dependencies between major modules and configuration parameters.

[1193] Step 7:

[1194] The terminal displays the analysis results received from the server in a user interface. The analysis results include the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The user interface is displayed in a visually easy-to-understand format.

[1195] Step 8:

[1196] The terminal provides a graphical dashboard that gives users an intuitive overview of the project, displaying heat maps and graphs that users can use to gain a better understanding of key codebases.

[1197] Step 9:

[1198] Based on the analysis, the server will suggest the order in which the user should start reading the code from, starting with the project's important configuration files and entry point files.

[1199] Step 10:

[1200] The terminal will display the suggested reading order on the user interface, allowing the user to start reading the code in this order and catch up on the project efficiently, thereby saving time and effort.

[1201] Step 11:

[1202] The emotion engine analyzes the user's facial expressions and voice in real time to recognize their emotions. It also collects emotional data through the camera and microphone to detect when the user is confused or stressed.

[1203] Step 12:

[1204] The server receives the analysis results of the emotion engine and dynamically changes the content and presentation of the user interface. For example, if the user is confused, it can provide more detailed guidance or step-by-step navigation, or display encouraging messages to motivate the user.

[1205] Step 13:

[1206] The device reflects the feedback from the emotion engine and provides the optimal user interface for the user, allowing the user to use the system comfortably and effectively progress with their learning and work.

[1207] Example 2

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

[1209] Traditionally, new engineers have struggled to quickly get up to speed on projects. These challenges include the difficulty of understanding the languages ​​and dependencies used within the repository, the time it takes to read code in an inappropriate order, and the lack of a way to recognize user emotions and improve learning efficiency. A new system is needed to address these challenges.

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

[1211] In this invention, the server includes means for retrieving source code from a Git repository, means for analyzing the retrieved source code to calculate the proportion of programming languages, means for analyzing configuration files in the source code to extract dependencies, means for visualizing the analysis results and displaying them in a user interface, means for proposing a program interpretation order based on the analysis results, means for recognizing and analyzing user emotions, and means for dynamically changing the content and presentation method of the user interface based on the emotion analysis results. This allows new engineers to efficiently catch up on projects and improves learning efficiency by providing appropriate support based on user emotions.

[1212] "Source code" is the text data of a program that defines the behavior of software.

[1213] A "Git repository" is a database used to manage source code and its change history in the Git version control system.

[1214] "Means" are specific technical means such as methods or devices for achieving a specific purpose.

[1215] "Analysis" is the process of breaking down information and clarifying its components and relationships.

[1216] A "programming language" is a set of rules and notations for creating programs that are executed by a computer.

[1217] "User interface" refers to the means or methods for inputting and outputting information between a user and a system.

[1218] A "dependency" is a relationship in which a piece of software depends on other specific software or libraries to function.

[1219] An "emotion engine" refers to an algorithm or device for recognizing and analyzing a user's emotions.

[1220] "Dynamic change" refers to changing content or settings in real time depending on the situation.

[1221] A "reading order" is the recommended order in which to begin reading a program or document in order to understand its contents in the proper order.

[1222] This invention is a system called "Program Handover Assistant" that retrieves source code from a Git repository and analyzes it to help new engineers quickly get up to speed on a project. Furthermore, by integrating an emotion engine that recognizes user emotions, the user experience can be improved. A specific embodiment of the system is described in detail below.

[1223] Specifying and cloning a repository

[1224] A user accesses the system and enters the URL of the Git repository they want to transfer. This is done through a web interface. The server clones the repository from the URL using the Git API and downloads it to the project directory on the server.

[1225] Language analysis

[1226] The server scans all files in the cloned repository, identifies the programming language based on the file extension, counts the number of files in each programming language, and calculates the percentage of each programming language used in the repository.

[1227] Parsing the configuration file

[1228] The server analyzes the main configuration files in the repository (e.g. package.json, requirements.txt). It parses these files to list the libraries and modules that the project depends on. It then analyzes the dependencies and gets an overview of the project's architecture.

[1229] Information Visualization

[1230] The terminal displays the analysis results received from the server on a user interface. The analysis results include the percentage of languages ​​used, a list of dependencies, and an overview of the architecture. The terminal also provides a graphical dashboard that allows engineers to intuitively understand the overall picture of the project. The dashboard displays heat maps and graphs.

[1231] Presenting the reading order

[1232] Based on the analysis results, the server will suggest to the engineer the appropriate order in which to read files and directories, allowing the engineer to start reading from important configuration files and entry points, and efficiently catch up on the project.

[1233] Emotion engine integration

[1234] The emotion engine analyzes the user's facial expressions and voice to recognize emotions in real time. It collects and analyzes the user's emotional data through a camera and microphone. The server dynamically changes the content and presentation of the user interface based on the emotion engine's analysis results. For example, if the user is feeling stressed, it will provide more considerate explanations and guidance.

[1235] Specific examples

[1236] Let's say a new engineer joins a project that's a web application that uses Python and JavaScript. The user enters the repository URL, and the server clones the repository. The server then analyzes the source code and determines that it's 60% Python and 40% JavaScript. The server also analyzes requirements.txt and package.json and lists the dependencies for each.

[1237] The terminal displays this information on a dashboard, and the server suggests an appropriate reading order (e.g., Django app settings file settings.py, main URL setting urls.py, React entry point index.js). Engineers can start reading the code in this order and quickly catch up on the project.

[1238] Furthermore, the emotion engine analyzes the user's facial expressions and voice in real time, and if the user is confused, the server adjusts the user interface to provide more detailed guidance and support, such as step-by-step navigation and demonstrations to help the user learn.

[1239] Prompt Sentence Examples

[1240] Describe a system that helps engineers joining a new project understand the project efficiently. This system retrieves source code from a Git repository, displays the analysis results on a dashboard, and suggests an appropriate reading order. It also includes a function that uses an emotion engine to recognize user emotions in real time and provide appropriate guidance. As a concrete example, imagine a web application project using Python and JavaScript.

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

[1242] Step 1:

[1243] Specifying and cloning a repository

[1244] A user accesses the system and enters the URL of the Git repository they want to take over, which is then entered into a text box on the web interface.

[1245] The server takes the input URL and clones the specified repository using the Git API. This operation downloads the entire contents of the repository into a project directory on the server. The input is the Git repository URL, and the output is the downloaded repository files.

[1246] Step 2:

[1247] Language analysis

[1248] The server scans all files in the downloaded repository, and this scanning is done using the file system API.

[1249] The server checks the extension of each file and determines the programming language based on that. For example, if the extension is ".py", it is determined to be Python, and if it is ".js", it is determined to be JavaScript.

[1250] The server counts the number of files in each identified programming language and calculates the percentage of the repository that each programming language occupies. The input is the file extension, and the output is the usage rate of each programming language.

[1251] Step 3:

[1252] Parsing the configuration file

[1253] The server identifies key configuration files in the repository (e.g., package.json, requirements.txt) and loads them.

[1254] The server parses the contents of the configuration file and lists the libraries and modules that the project depends on, using a JSON parser or text analysis tool.

[1255] The server analyzes dependencies and understands the relationships between major modules. The input is a configuration file, and the output is a list of dependent libraries and modules.

[1256] Step 4:

[1257] Information Visualization

[1258] The server generates and sends the analysis results to the device, which include the percentage of programming languages ​​used, a list of dependent libraries, and a summary of the project's architecture.

[1259] A graphical dashboard is provided based on the analysis results received by the device. This dashboard displays heat maps and various graphs. The input is the analysis result data, and the output is the displayed dashboard.

[1260] Step 5:

[1261] Presenting the reading order

[1262] Based on the analysis, the server recommends the order in which the engineer should start reading from, prioritizing important configuration files and entry points.

[1263] The terminal displays the recommended parsing order in the user interface, and the engineer can start reading the code according to this order. The input is the parsing result, and the output is the recommended parsing order.

[1264] Step 6:

[1265] Emotion engine integration

[1266] The emotion engine analyzes the user's facial expressions and voice in real time to recognize their emotional state, using data collected through the camera and microphone.

[1267] The server receives the analysis results of the emotion engine and dynamically changes the content and presentation of the user interface depending on the user's stress level or confusion, for example, by providing more detailed guidance or step-by-step explanations. The input is emotion data, and the output is an adjusted user interface.

[1268] This allows new engineers to efficiently understand the project from the key parts in the repository and quickly catch up, and the emotion engine provides appropriate support.

[1269] (Application example 2)

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

[1271] With the advancement of information technology, it has become common for many companies and organizations to use multiple programming languages ​​and libraries in software development projects. However, when new engineers join a project, it is difficult for them to understand the code base and dependencies within the project and quickly catch up. Furthermore, maintaining factory robots requires an understanding of complex systems, making it difficult for new engineers to work efficiently in a short period of time. In addition, stress and confusion can cause a significant drop in work efficiency. An effective method to solve these problems is needed.

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

[1273] In this invention, the server includes means for retrieving source code from a Git repository, means for analyzing the retrieved source code and calculating the proportion of programming languages, means for analyzing configuration files in the source code and extracting dependencies, means for visualizing the analysis results and displaying them in a user interface, means for proposing a program interpretation order based on the analysis results, means for recognizing emotions by analyzing a user's facial expressions and voice, and means for dynamically changing the content and presentation method of the user interface based on the emotion recognition results. This not only enables new engineers to quickly catch up on projects and factory robot systems and work efficiently, but also enables optimal support to be provided according to the user's emotional state.

[1274] A "Git repository" is a database for version control in software development, which tracks the change history of source code and allows multiple developers to work together.

[1275] "Source code" means computer program instructions written in a programming language in a form that can be understood and executed by a computer.

[1276] "Programming language proportion" is a metric that indicates the usage rate of various programming languages ​​used within a particular project or repository, and represents the proportion of each language in the total.

[1277] A "configuration file" is a file that describes various settings and dependencies in a software project, and specifically includes version information for libraries and modules.

[1278] A "dependency" refers to a relationship in which one software component or module depends on another component or module, such that one component requires the other component to function correctly.

[1279] "Visualization" refers to the visual representation of data or information, which makes it easier for users to intuitively understand the information.

[1280] A "user interface" is an interface that allows a user to interact with a computer system, and is operated using a graphical display and input device.

[1281] A "reading order" is the order in which a new engineer should read through the files and directories to understand the source code of a project.

[1282] "Facial expressions" are expressions on a human face that change to show emotions and intentions.

[1283] "Speech" refers to the sound produced by the human voice and is used to convey various information, including emotions and intentions.

[1284] "Emotion recognition" is a technology that analyzes a user's facial expressions and voice to estimate their emotional state at that time.

[1285] "Dynamic change" means that the system automatically changes its content and behavior in real time according to the situation, thereby providing users with the most appropriate information and operating methods.

[1286] This invention provides a "Robot Maintenance Assistant" that streamlines factory robot maintenance and helps new engineers quickly understand the system. Specific embodiments of this system are described below.

[1287] 1. Server Processing

[1288] The server receives the URL of the Git repository specified by the user. Based on the URL entered by the user, the server uses the Git API to clone the repository and save it to a local directory. The server then analyzes the saved source code to determine the proportion of programming languages ​​used and dependencies. To analyze dependencies, it parses the main configuration files in the repository (e.g., package.json and requirements.txt).

[1289] 2. Information visualization

[1290] The results of the analysis by the server are displayed on a graphical dashboard. Information such as the proportion of various programming languages, an overview of dependencies, and the main architecture is visually displayed, allowing engineers to intuitively understand it. For this purpose, the dashboard library is used.

[1291] 3. Suggested reading order

[1292] Based on the analysis results, the server will suggest which files and directories the engineer should start reading from, especially important configuration files and entry point files, allowing the engineer to catch up efficiently.

[1293] 4. Emotion recognition

[1294] The server is equipped with an emotion engine (e.g., the emotion_recognition library) that analyzes the user's facial expressions and voice in real time and recognizes their emotions. Emotional data is collected through a camera and microphone, and the content and presentation of the interface are dynamically changed if the user is feeling stressed or confused. Specifically, it provides more detailed guidance and step-by-step navigation.

[1295] 5. Specific Examples

[1296] Imagine a new maintenance engineer at a factory needs to quickly understand a Git repository for control software for a new industrial robot. The user enters the repository URL, and the server clones and analyzes it. The analysis results are displayed on a dashboard, showing the proportion of programming languages ​​and dependencies at a glance. An emotion engine monitors the user's facial expressions and voice, and if stress or confusion is detected, it provides detailed instructions and guidance.

[1297] Prompt Sentence Examples

[1298] You are designing an assistant to help factory maintenance engineers quickly understand the Git repository for a new robotics system. The system will clone and analyze the repository, visualize the results, and dynamically adjust the interface based on emotion recognition. Write the code to implement this system using Python.

[1299] In this way, the invention not only helps new engineers quickly get up to speed on projects, but also creates a system that provides optimal support depending on the emotions that arise during the process.

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

[1301] Step 1:

[1302] The user accesses the system's web interface and enters the URL of the Git repository they want to take over, which is then sent to the server.

[1303] Step 2:

[1304] The server receives the URL of the Git repository and clones it using the Git API. At this time, the source code of the cloned repository is downloaded to a local directory. The input is the repository URL, and the output is the source code saved in the local directory.

[1305] Step 3:

[1306] The server scans the source code stored in the local directory and determines the programming language used based on the file extension of each file. It then counts the number of files for each identified programming language and calculates the percentage of each language in the total. The input is the source code, and the output is the percentage of programming languages.

[1307] Step 4:

[1308] The server parses the main configuration files in the repository (e.g., package.json, requirements.txt) and extracts dependencies. It parses each configuration file and lists the libraries and modules that the project depends on. The input is the configuration file, and the output is the list of dependencies.

[1309] Step 5:

[1310] The server processes the percentage of programming languages ​​and the list of dependencies into data for display on a graphical dashboard and sends it to the terminal. The input is the percentage of programming languages ​​and the list of dependencies, and the output is the data for displaying on the dashboard.

[1311] Step 6:

[1312] The terminal receives the data sent from the server and displays the analysis results on a graphical dashboard. The percentage of languages ​​used, a list of dependencies, and an overview of the architecture are visually displayed. The input is the data to be displayed on the dashboard, and the output is the displayed dashboard.

[1313] Step 7:

[1314] Based on the analysis, the server suggests an order in which the engineer should start reading files and directories, recommending that they start with the main configuration file or entry point. The input is the analysis results, and the output is the suggested parsing order.

[1315] Step 8:

[1316] The terminal displays the parsing order received from the server on the user interface. The engineer can start reading the code according to this order. The input is the parsing order, and the output is the order displayed on the user interface.

[1317] Step 9:

[1318] The server uses an emotion engine to analyze the user's facial expressions and voice in real time to recognize emotions. Emotion data is collected through the camera and microphone and analyzed. The input is data from the camera and microphone, and the output is the recognized emotion.

[1319] Step 10:

[1320] The server dynamically changes the content and presentation of the user interface based on the emotion recognition results. If the user is feeling stressed, it provides detailed guidance and step-by-step navigation. The input is the recognized emotion, and the output is the dynamically changed user interface.

[1321] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

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

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

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

[1325] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1326] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1327] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1328] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, motorcycles, and other devices, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

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

[1330] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1331] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1332] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

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

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

[1335] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1336] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1337] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1338] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1339] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1340] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1341] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1342] The following is further disclosed regarding the above embodiment.

[1343] (Claim 1)

[1344] A way to get the source code from the Git repository,

[1345] A means for analyzing the acquired source code and calculating the proportion of programming languages;

[1346] A means of extracting dependencies by analyzing configuration files in the source code;

[1347] A means for visualizing the analysis results and displaying them in a user interface;

[1348] A method for proposing a program interpretation order based on the analysis results;

[1349] A system including:

[1350] (Claim 2)

[1351] 2. The system according to claim 1, wherein the means for calculating the percentage of programming languages ​​used by analyzing the source code makes the determination based on the extension of the source code file.

[1352] (Claim 3)

[1353] 2. The system according to claim 1, wherein the means for extracting dependencies by analyzing the configuration files parses a plurality of configuration files that are dependent on programming languages.

[1354] "Example 1"

[1355] (Claim 1)

[1356] A means to receive a user-specified repository URL and clone that repository,

[1357] A means of scanning all files in the cloned repository to identify the programming languages ​​used and calculate the proportion of each language;

[1358] A means of parsing key configuration files and extracting project dependencies;

[1359] A means for visualizing the analysis results and displaying them on a user interface;

[1360] A method for proposing a program interpretation order based on the analysis results;

[1361] A system including:

[1362] (Claim 2)

[1363] 2. The system of claim 1, further comprising means for calculating the percentage of programming languages ​​used based on the extensions of all files in the repository.

[1364] (Claim 3)

[1365] 10. The system of claim 1, further comprising means for parsing a primary configuration file and extracting dependencies corresponding to multiple programming languages.

[1366] "Application Example 1"

[1367] (Claim 1)

[1368] A way to get the source code from the Git repository,

[1369] A means for analyzing the acquired source code and calculating the proportion of programming languages;

[1370] A means of extracting dependencies by analyzing configuration files in the source code;

[1371] A means for visualizing the analysis results and displaying them in a user interface;

[1372] A method for proposing a program interpretation order based on the analysis results;

[1373] A means to quickly install new software on industrial machines and complete their configuration;

[1374] A system including:

[1375] (Claim 2)

[1376] 2. The system according to claim 1, wherein the means for calculating the percentage of programming languages ​​used by analyzing the source code makes the determination based on the extension of the source code file.

[1377] (Claim 3)

[1378] The system of claim 1, wherein the means for extracting dependencies by analyzing configuration files parses multiple configuration files that depend on the programming language and provides appropriate configuration procedures for industrial machines.

[1379] "Example 2: Combining Emotion Engines"

[1380] (Claim 1)

[1381] A way to get the source code from the Git repository,

[1382] A means for analyzing the acquired source code and calculating the proportion of programming languages;

[1383] A means of extracting dependencies by analyzing configuration files in the source code;

[1384] A means for visualizing the analysis results and displaying them in a user interface;

[1385] A method for proposing a program interpretation order based on the analysis results;

[1386] means for recognizing and analyzing user emotions;

[1387] A means for dynamically changing the content and presentation method of the user interface based on the emotion analysis results;

[1388] A system including:

[1389] (Claim 2)

[1390] 2. The system according to claim 1, wherein the means for calculating the percentage of programming languages ​​used by analyzing the source code makes the determination based on the extension of the source code file.

[1391] (Claim 3)

[1392] 2. The system according to claim 1, wherein the means for extracting dependencies by analyzing the configuration files parses a plurality of configuration files that are dependent on programming languages.

[1393] "Application example 2 when combining emotion engines"

[1394] (Claim 1)

[1395] A way to get the source code from the Git repository,

[1396] A means for analyzing the acquired source code and calculating the proportion of programming languages;

[1397] A means of extracting dependencies by analyzing configuration files in the source code;

[1398] A means for visualizing the analysis results and displaying them in a user interface;

[1399] A method for proposing a program interpretation order based on the analysis results;

[1400] A means for recognizing emotions by analyzing the user's facial expressions and voice;

[1401] A means for dynamically changing the content and presentation method of the user interface based on the emotion recognition result;

[1402] A system including:

[1403] (Claim 2)

[1404] 2. The system according to claim 1, wherein the means for calculating the percentage of programming languages ​​used by analyzing the source code makes the determination based on the extension of the source code file.

[1405] (Claim 3)

[1406] 2. The system according to claim 1, wherein the means for extracting dependencies by analyzing the configuration files parses a plurality of configuration files that are dependent on programming languages. [Explanation of symbols]

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

Claims

1. A way to get the source code from the Git repository, A means for analyzing the acquired source code and calculating the proportion of programming languages; A means of extracting dependencies by analyzing configuration files in the source code; A means for visualizing the analysis results and displaying them in a user interface; A method for proposing a program interpretation order based on the analysis results; A system including:

2. 2. The system according to claim 1, wherein the means for calculating the percentage of the programming language used by analyzing the source code makes the determination based on the extension of the source code file.

3. 2. The system according to claim 1, wherein the means for extracting dependencies by analyzing the configuration files parses a plurality of configuration files that are dependent on programming languages.

Images