System

Abstract

A system is provided.SOLUTION: A system comprising: means for a user to upload a code file from a terminal; means for a server to receive and forward the code file to an analysis engine; means for the analysis engine to analyze the code file and identify error points and improvements; and means for returning the analysis results to the user.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] Traditionally, code reviews in software development have mainly been conducted manually, which is time-consuming and costly. Furthermore, those being reviewed are prone to experiencing interpersonal stress due to criticism, which can lead to reduced productivity. Furthermore, it is often difficult to check code in accordance with the specific coding rules of each company or project. The purpose of this invention is to solve these problems and provide an efficient and stress-free code review environment. [Means for solving the problem]

[0005] The system includes a means for users to upload code files from their devices, a server to receive the code files and transfer them to an analysis engine, a means for the analysis engine to analyze the code files and identify errors and areas for improvement, and a means for returning the analysis results to the user. It also includes a means for analyzing the contents of the code files uploaded by users based on company-specific rules, and a means for storing the analysis results in a database so that the user can retrieve them as needed. This configuration enables the automation and efficiency of code reviews, reduces interpersonal stress, and supports company-specific coding rules.

[0006] "User" means an entity that uses this system to upload code files and receive analysis results.

[0007] A "terminal" is a device used by a user, such as a computer, smartphone, or tablet.

[0008] "Code File" means a file containing user-created program code.

[0009] "Uploading" is the process by which a user sends a code file from their device to a server.

[0010] A "server" is a computer system on a network that transfers code files received from users to an analysis engine and manages the analysis results.

[0011] An "analysis engine" is software or hardware that analyzes code files transferred from a server and identifies errors and areas for improvement.

[0012] An "error location" refers to a programming error or bug that exists in a code file.

[0013] "Improvements" are suggestions and corrections to make the code file more efficient and of higher quality.

[0014] "Company-specific rules" are coding styles and guidelines established within a particular company or project.

[0015] A "database" is a storage system that stores analytical results and other related information so that they can be searched or retrieved as needed.

[0016] The "analysis results" are information including errors and improvements detected by the analysis engine.

[0017] "Re-acquisition" is the process by which a user re-acquires previously saved analysis results. [Brief explanation of the drawings]

[0018] [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

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

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

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

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

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

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

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

[0026] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0039] The present invention begins with the user uploading a code file from their device. The user launches the application on their device, clicks the "Upload" button, selects the code file, and sends it to the server. The device then generates an HTTP request and sends the user ID along with the code file to the server.

[0040] The server analyzes the received HTTP request, extracts the code file and user ID, then reads the code file and passes its contents to the analysis engine, which analyzes the contents of the code file and identifies errors and areas for improvement.

[0041] The analysis engine checks the code according to not only standard programming rules but also company-specific rules, enabling code reviews to be performed in accordance with company- or project-specific guidelines, improving quality. Once the analysis is complete, the analysis engine sends the results back to the server.

[0042] The server stores the analysis results received from the analysis engine in a database. To make it easier for users to retrieve the analysis results, the analysis results are managed in association with the user ID. If the user wants to check the analysis results again later, they can send a request from their device to the server and retrieve the analysis results.

[0043] As a concrete example, consider the case where User A uploads a Python code file called "example.py" to "Code Review Plus." When User A clicks the upload button and specifies the file, the device sends the file and User A's ID to the server. The server receives the file and transfers the contents to the analysis engine. The analysis engine analyzes "example.py" and finds specific errors and areas for improvement. The results are sent back to the server and stored in a database linked to User A's ID. When User A clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device.

[0044] This will enable User A to undergo code reviews at their own pace without experiencing interpersonal stress, improving the quality of their code, and significantly reducing the human costs and time required for reviews.

[0045] The processing flow will be explained below.

[0046] Step 1:

[0047] A user launches the application on their device, selects a code file, and clicks the "Upload" button. The device generates an HTTP request containing the selected code file and the user ID and sends it to the server.

[0048] Step 2:

[0049] The server receives the HTTP request, analyzes the request, extracts the code file and the user ID, and temporarily stores the received code file in preparation for analysis.

[0050] Step 3:

[0051] The server passes the contents of the code file to the analysis engine, which receives the code file transferred from the server and begins analyzing it.

[0052] Step 4:

[0053] The analysis engine analyzes the syntax of the code file, identifies errors and areas for improvement, checks the code against company-specific rules, and generates analysis results, which are then sent back to the server.

[0054] Step 5:

[0055] The server receives the analysis results, associates them with the user ID, and stores them in the database, allowing the user to check the results later.

[0056] Step 6:

[0057] The user clicks the "Show analysis results" button. The device generates an HTTP request including the user ID and requests the server to retrieve the analysis results.

[0058] Step 7:

[0059] The server receives the HTTP request, retrieves the analysis results corresponding to the user ID from the database, and returns them to the device. The analysis results are displayed on the user's device.

[0060] Step 8:

[0061] Users can check the analysis results on their devices, correct their own code based on errors and improvements, and take action to improve the quality of their code.

[0062] Through these steps, users will be able to undergo code reviews efficiently and stress-free at their own pace. In addition, the link between the server and the analysis engine will automate the review process, reducing human costs and time.

[0063] Example 1

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

[0065] Conventional code analysis systems are limited to simply detecting syntax errors in code, and do not perform analysis based on company-specific coding rules, which is insufficient in terms of quality control.In addition, there is no mechanism for users to easily retrieve analysis results, making efficient code reviews difficult.

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

[0067] In this invention, the server includes: means for a user to upload a program file from an information processing device; means for the information processing device to send a HyperText Transfer Protocol request including the program file and identification information to the server; means for the server to receive the HyperText Transfer Protocol request and transfer the program file and identification information to an analysis engine; means for the analysis engine to analyze the program file according to normal programming rules and specific rules and identify errors and areas for improvement; means for saving the analysis results in a database and managing them linked to the identification information; means for the user to send a request from the information processing device to the server so that the user can re-obtain the analysis results as needed; and means for the server to receive the request, obtain the analysis results from the database, and send them to the information processing device. This enables detailed code analysis based on company-specific rules and allows users to easily re-obtain the analysis results, thereby achieving efficient code review and quality control.

[0068] "User" means any person or entity that uses the System to upload Program Files.

[0069] An "information processing device" refers to a device used by a user, such as a computer or smartphone.

[0070] "Program File" means a file containing code uploaded by a User.

[0071] "Identifying Information" means data that includes a user's ID or other identifiable information.

[0072] "Hypertext Transfer Protocol Request" means a standardized protocol used to send and receive data between an information processing device and a server.

[0073] "Server" refers to a computer system that has the function of receiving requests sent by users and linking them to an analysis engine.

[0074] An "analysis engine" is software that analyzes program files and identifies errors and areas for improvement.

[0075] "Normal programming practices" refers to common coding style and standard programming rules.

[0076] "Specific rules" are special coding rules established by a company or a specific project.

[0077] "Analysis results" refers to information about errors and areas for improvement obtained by the analysis engine when it analyzes a program file.

[0078] A "database" is a digital storage system for storing analysis results.

[0079] A "request" is a request sent by a user to a server to retrieve analysis results.

[0080] The present invention relates to a system that allows a user to upload a program file from their own information processing device, analyze the file using an analysis engine, identify errors and areas for improvement, and manage and reacquire the analysis results.

[0081] First, a user launches the application using an information processing device (such as a computer or smartphone) and clicks the "Upload" button. The user then selects a program file (e.g., example.py) to upload from their local disk. At this time, the information processing device generates a Hypertext Transfer Protocol (HTTP) request containing the selected program file and the user's identification information (e.g., user123) and sends it to the server.

[0082] The server analyzes the incoming HTTP request and extracts the program file and user identification information. The server then temporarily stores the file and transfers its contents to the analysis engine. The analysis engine then performs a detailed analysis of the code according to standard programming rules and company-specific rules. For example, it identifies errors and areas for improvement, such as syntax errors, undefined variables, and areas that need refactoring.

[0083] Once the analysis is complete, the analysis engine returns the results in JSON format to the server. The server saves these analysis results in a database and manages them linked to the user's identification information. This allows the user to check the analysis results again later. When the user clicks the "Check Results" button, a request to re-acquire the results is sent from the information processing device to the server. The server retrieves the analysis results from the database and returns them to the information processing device. The information processing device displays the returned analysis results to the user.

[0084] Examples:

[0085] We will explain the case where User A uploads a Python code file "example.py" and obtains the analysis results. User A starts the application and clicks the "Upload" button to specify the file "example.py." The information processing device generates an HTTP request containing this file and User A's identification information and sends it to the server. The server receives the request, temporarily saves the file, and then transfers the contents to the analysis engine. The analysis engine analyzes the file, identifies errors and areas for improvement, and returns the results to the server. The server saves the analysis results in a database and links them to User A's identification information. When User A clicks the "Check Results" button, the server retrieves the results from the database and returns them to the information processing device for display.

[0086] Example prompt sentence:

[0087] A user wants to upload a Python code file, "example.py," for code review. The system begins when the user launches the application on their device and presses the "Upload" button to send the code file to the server. An HTTP request containing the user ID and code file is generated and sent to the server. The server parses the request and extracts the code file and user ID. The server then passes the code file to an analysis engine, which analyzes it, taking into account company-specific rules, to identify errors and areas for improvement. The analysis results are sent back to the server and stored in a database. When the user sends a request from their device to the server to view the analysis results, the server retrieves the results from the database and sends them back to the device. The device displays the analysis results to the user. Please explain this process in detail.

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

[0089] Step 1:

[0090] The user launches the application on the terminal. The user clicks the "Upload" button in the application and selects a program file (e.g., example.py) from the local disk. This operation specifies the program file to be uploaded and performs input operations related to that file.

[0091] Step 2:

[0092] The terminal generates an HTTP POST request containing the program file and user ID selected by the user. This request converts the data of the program file (example.py) and user ID (user123) into HyperText Transfer Protocol format and prepares it for transmission to the server.

[0093] Step 3:

[0094] The server analyzes the HTTP POST request received from the terminal. The server extracts the program file (example.py) and user ID (user123) from the request. In this analysis step, data analysis processing is performed to understand the data structure of the request and extract the necessary information.

[0095] Step 4:

[0096] The server saves the extracted program file in a temporary storage area. Next, it reads the contents of the program file and passes the data to the analysis engine. This read and transfer operation is a data transfer process that temporarily stores the file contents and passes them to the analysis engine.

[0097] Step 5:

[0098] The analysis engine analyzes the received program files and identifies errors and areas for improvement based on standard programming rules and company-specific rules. This analysis process involves syntactic analysis of the code in the program files and data analysis to identify errors and violations of coding rules.

[0099] Step 6:

[0100] Once the analysis is complete, the analysis engine returns the analysis results in JSON format to the server. This return operation is a data communication process that converts the analysis results into a structured data format and sends it to the server.

[0101] Step 7:

[0102] The server saves the analysis results in JSON format received from the analysis engine in a database. The server manages the analysis results by linking them to the user ID (user123). This saving and management operation is a database operation that registers the analysis results in a database (e.g., MySQL) so that they can be referenced later.

[0103] Step 8:

[0104] The user sends a request from the device to the server to check the analysis results. The device generates an HTTP GET request such as " / getResults?userID=user123" and sends it to the server. This operation is a data transfer process for generating and sending a data re-acquisition request.

[0105] Step 9:

[0106] The server analyzes the received HTTP GET request and retrieves the analysis results associated with the user ID from the database. This retrieval operation is a database access process that searches for and retrieves the required data from the database.

[0107] Step 10:

[0108] The server sends the acquired analysis results to the terminal as an HTTP response. The terminal displays the received analysis results to the user. This display operation is a data display process that visually presents the analysis results to the user.

[0109] (Application example 1)

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

[0111] In conventional code review systems, developers upload code in a local environment and check the results later, but real-time feedback is not available, which reduces development efficiency. Additionally, in specialized environments such as factories, it is difficult to point out program errors and areas for improvement in a timely manner, making it difficult to improve program quality.

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

[0113] In this invention, the server includes a means for users to upload code files from their terminals, a means for the server to receive the code files and transfer them to an analysis engine, a means for the analysis engine to analyze the code files and identify errors and areas for improvement, a means for returning the analysis results to the user, and a means for being directly installed on machines installed in a factory. This allows machines in a factory to identify errors and areas for improvement in program code in real time and display immediate feedback. Furthermore, the analysis results can be saved and retrieved and displayed as needed, improving development efficiency and maintaining quality.

[0114] "Code File" means a file containing program code created by a User.

[0115] "Terminal" refers to a device operated by a user, including smartphones, tablets, computers, etc.

[0116] "Server" means a networked computer system that receives uploaded code files, transmits them to the analysis engine, and manages the analysis results.

[0117] "Analysis Engine" means software or algorithms that analyze the contents of code files and identify errors and areas for improvement.

[0118] "Error locations" refer to defects or problems in the program code that are discovered when the analysis engine analyzes the code file.

[0119] "Improvements" refer to areas that the analysis engine determines, through analysis of the code file, require correction.

[0120] "Analysis Results" refers to information about errors and areas for improvement generated by the analysis engine after analyzing a code file.

[0121] "Machinery installed in a factory" refers to robots, equipment, etc. that are actually operating and operated within the factory.

[0122] "Display in real time" means that the analysis results are immediately reflected on the display device.

[0123] "Display device" refers to a device installed on a machine or terminal in a factory, which visually displays analysis results and other information.

[0124] "Means for returning to user" refers to the communication means for sending the analysis results back to the user's terminal or factory machine.

[0125] "Factory-specific rules" refers to the unique programming guidelines and standards that operate within a particular factory or company.

[0126] "Means for storing analysis results" refers to the methods and technologies for recording analysis results in storage such as a database.

[0127] This invention relates to a system that allows users to upload code files from a terminal and check the analysis results. This system is particularly applicable to machines installed in factories, and is capable of identifying code errors and areas for improvement in real time and displaying feedback.

[0128] First, a user uploads a code file using a dedicated application on a device such as a smartphone or computer. The device generates an HTTP request and sends the code file along with the user ID to the server. This allows the server to receive the code file and transfer it to the analysis engine.

[0129] The server then passes the received code files to an analysis engine, which analyzes the code based on normal programming rules and factory-specific rules to identify errors and areas for improvement. This analysis engine may include machine learning models or rule-based engines.

[0130] Once the analysis is complete, the server stores the results received from the analysis engine in a database, which stores the analysis results associated with each user ID.

[0131] Machines installed in factories are equipped with displays to display the analysis results. These displays retrieve the analysis results from the server as needed and provide feedback to the user in real time. Machines can frequently check for program errors and areas for improvement while they are operating, allowing for prompt corrections.

[0132] For example, when Robot A operating in a factory uploads a new control code file "control_script.py," Robot A can display the analysis results in real time on a display on the spot. For example, an error such as "Syntax error: Missing closing parenthesis (line 23)" is displayed, allowing the developer to take immediate action.

[0133] Examples of prompts to input to a generative AI model include:

[0134] "Please describe an application that automatically detects syntax errors and areas for improvement in the control code of machines installed in a factory, and displays feedback in real time. Please also show how to implement it using Python code, including specific functions and execution examples."

[0135] This invention allows factory equipment to check program code in real time and instantly display the analysis results, which is expected to significantly improve development efficiency and program code quality.

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

[0137] Step 1:

[0138] The terminal uploads the code file selected by the user. The user launches the terminal application and clicks the "Upload" button to select the code file. The selected file and the user ID are sent to the server via an HTTP request.

[0139] Input: User selected code file, User ID

[0140] Data manipulation: Combine the code file and user ID in the HTTP request

[0141] Output: HTTP request sent to the server

[0142] Step 2:

[0143] The server parses the received HTTP request and extracts the code file and user ID, which are then passed to the parsing engine.

[0144] Input: HTTP request (code file, user ID)

[0145] Data processing: Parsing HTTP requests, extracting code files and user IDs

[0146] Output: A code file that is passed to the analysis engine.

[0147] Step 3:

[0148] The analysis engine analyzes the received code file, following normal programming rules and factory-specific rules to identify errors and areas for improvement.

[0149] Input: Code file

[0150] Data processing: analyzing the code, identifying errors and areas for improvement

[0151] Output: Analysis results (errors, improvements)

[0152] Step 4:

[0153] The server stores the analysis results received from the analysis engine in a database, where they are linked to the user ID.

[0154] Input: Analysis results, user ID

[0155] Data processing: Analysis results are saved based on user ID.

[0156] Output: Analysis results stored in a database

[0157] Step 5:

[0158] When a user sends a request to check the analysis results from a terminal or a machine installed in a factory, the server retrieves the stored analysis results and returns them to the user.

[0159] Input: User request

[0160] Data processing: Search and extract saved analysis results

[0161] Output: Returning analysis results to user terminal or machine display

[0162] Step 6:

[0163] The analysis results are displayed in real time on the displays of the machines installed in the factory, allowing users to immediately check for errors and areas for improvement.

[0164] Input: Analysis results

[0165] Data processing: Display analysis results on the screen

[0166] Output: Feedback to the user

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

[0168] The present invention begins with the user uploading a code file from their device. The user launches the application on their device, selects the code file, and clicks the "Upload" button. The device then generates an HTTP request containing the selected code file and the user ID and sends it to the server.

[0169] The server analyzes the received HTTP request and extracts the code file and user ID. It then reads the code file and passes its contents to the analysis engine. The analysis engine analyzes the contents of the code file and identifies errors and areas for improvement. The analysis engine checks the code based on not only standard programming rules but also company-specific rules. Once the analysis is complete, it sends the results back to the server.

[0170] The server stores the analysis results received from the analysis engine in a database, linking them to the user ID. The analysis results are stored in an appropriate format so that users can easily retrieve them again.

[0171] The present invention further includes an emotion engine that recognizes the user's emotions. When the user displays the analysis results, the emotion engine analyzes the user's emotions based on their facial expressions, tone of voice, or input data. Based on the analyzed emotions, the emotion engine adjusts the presentation method and order of the analysis results. This reduces user stress and provides more effective feedback.

[0172] As a concrete example, consider the case where User A uploads his / her Python code "example.py" to "Code Review Plus." When User A clicks the upload button and specifies a file, the device sends the file and User A's ID to the server. The server receives the file and transfers its contents to the analysis engine. The analysis engine analyzes "example.py" and finds specific errors and areas for improvement. The analysis results are sent back to the server and stored in a database linked to User A's ID.

[0173] When User A clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device. At this point, the emotion engine analyzes User A's emotions, and if it determines that User A is feeling stressed, it adjusts the presentation method and order of the analysis results to provide feedback in a format that is easy for User A to understand.

[0174] This allows User A to undergo code reviews at their own pace without experiencing interpersonal stress and improve the quality of their code. The introduction of an emotion engine also provides customized feedback based on each user's psychological state, enabling more effective learning and improvement. It also significantly reduces the human costs and time required for reviews.

[0175] By recognizing user sentiment and providing analysis results based on it, this system will be able to provide a better user experience than traditional code review systems.

[0176] The processing flow will be explained below.

[0177] Step 1:

[0178] A user launches the application on their device, selects a code file, and clicks the "Upload" button. The device generates an HTTP request containing the selected code file and the user ID and sends it to the server.

[0179] Step 2:

[0180] The server receives the HTTP request, analyzes the request, extracts the code file and the user ID, and temporarily stores the received code file in preparation for analysis.

[0181] Step 3:

[0182] The server passes the contents of the code file to the analysis engine, which receives the code file transferred from the server and begins analyzing it.

[0183] Step 4:

[0184] The analysis engine analyzes the syntax of the code file, identifies errors and areas for improvement, performs checks including company-specific rules, and generates analysis results, which are then sent back to the server.

[0185] Step 5:

[0186] The server receives the analysis results, associates them with the user ID, and stores them in the database, allowing the user to check the results later.

[0187] Step 6:

[0188] The user clicks the "Show analysis results" button. The device generates an HTTP request including the user ID and requests the server to retrieve the analysis results.

[0189] Step 7:

[0190] The server receives the HTTP request, retrieves the analysis results corresponding to the user ID from the database, and returns them to the device. The analysis results are displayed on the user's device.

[0191] Step 8:

[0192] The emotion engine collects data (facial expressions, tone of voice, input data, etc.) to analyze the user's emotions. The user's emotions are analyzed based on this data.

[0193] Step 9:

[0194] The emotion engine adjusts the presentation and order of analysis results based on the user's emotions. The order in which analysis results are displayed and the content of feedback can be customized to reduce stress.

[0195] Step 10:

[0196] Users can check the analysis results on their devices, correct their own code based on errors and improvements, and take action to improve the quality of their code.

[0197] Through these steps, users can undergo code reviews efficiently and stress-free at their own pace, and by customizing the analysis results using the emotion engine, they can receive more effective feedback.

[0198] Example 2

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

[0200] Current code review systems primarily check code based on general programming rules and do not address company-specific rules. Furthermore, when users receive information about errors or improvements, there is no mechanism to present the information in an easy-to-understand format, which can increase user stress. This makes it difficult to effectively improve code quality, and the user experience during the review process is not improved.

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

[0202] In this invention, the server includes means for a user to upload a code file from a terminal, means for the server to receive the code file and transfer it to an analysis engine, means for the analysis engine to analyze the code file and identify errors and areas for improvement, means for returning the analysis results to the user, and means for the emotion engine to recognize the user's emotions and adjust the way in which the analysis results are presented. This makes it possible to comply with company-specific rules and provide effective feedback while reducing user stress.

[0203] "User" refers to an individual or corporation that uses the system.

[0204] "Terminal" refers to a device used by a user, such as a computer or smartphone.

[0205] A "code file" refers to a file in which the source code of a program is written.

[0206] A "server" refers to a computer system that receives and processes requests from users.

[0207] An "analysis engine" is a software system that analyzes code files and identifies errors and areas for improvement.

[0208] An "error location" refers to a part of a code file that causes the program to not function properly.

[0209] "Improvements" refer to areas of a code file that are recommended to be fixed in order to improve the quality of the program.

[0210] An "emotion engine" refers to a software system that recognizes a user's emotions and adjusts the way feedback is presented based on those emotions.

[0211] "Analysis results" refers to data containing information on errors and areas for improvement obtained by the analysis engine.

[0212] "Company-specific rules" refer to unique guidelines regarding programming and coding established by a particular company.

[0213] A "database" refers to a system for efficiently storing and managing data such as analysis results.

[0214] The present invention begins with a user uploading a code file from their device. Specifically, the user launches an application on their device, selects the code file they want to upload, and clicks the "Upload" button. This causes the device to generate an HTTP request containing the selected code file and their user ID and send it to the server.

[0215] The server analyzes the received HTTP request and extracts the code file and user ID. This process requires common server software and an analysis engine (e.g., a lint tool or custom analysis software). The server then reads the code file and passes it to the analysis engine. The analysis engine analyzes the contents of the code file and identifies errors and areas for improvement. The analysis engine checks the code based on standard programming rules as well as company-specific rules. Once the analysis is complete, the results are sent back to the server.

[0216] Next, the server stores the analysis results received from the analysis engine in a database, linking them to the user ID. When storing the results, the server stores them in a format that makes it easy for users to retrieve them again. This allows users to check past analysis results as needed.

[0217] The present invention further includes an emotion engine for recognizing a user's emotions. When a user displays analysis results, the emotion engine analyzes the user's emotions based on their facial expressions, tone of voice, and input data. Based on the analysis results, the presentation method and order of the analysis results are adjusted to reduce user stress. For example, if a user is feeling stressed, the user experience can be improved by presenting errors in order of ease.

[0218] As a concrete example, consider the case where User A uploads his or her own Python code "example.py." When User A clicks the "Upload" button and specifies the file, the device sends "example.py" and User A's ID to the server. The server receives the file and transfers its contents to the analysis engine. The analysis engine analyzes "example.py" and finds specific errors and areas for improvement. The analysis results are sent back to the server and stored in a database linked to User A's ID.

[0219] When User A clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device. At this time, the emotion engine analyzes User A's emotions, and if it determines that User A is feeling stressed, it adjusts the presentation method and order of the analysis results to provide feedback in a format that is easy for User A to understand.

[0220] An example of a prompt for the generative AI model in this system is:

[0221] "Please describe a system where users upload code files from their devices, and a server analyzes the files and points out errors and areas for improvement. Also, please detail the functionality that adjusts the way feedback is presented based on the user's emotions."

[0222] That's all.

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

[0224] Step 1:

[0225] The user launches the application on their device and selects the code file they want to upload. The input is the user-selected code file (e.g., "example.py") and their user ID. This action causes the device to generate an HTTP request containing the selected code file and their user ID and send it to the server as output.

[0226] Step 2:

[0227] The server analyzes the received HTTP request and extracts the code file and user ID. The input is the HTTP request sent from the terminal. The server first analyzes the request data and separates the code file (e.g., "example.py") and the user ID (e.g., "UserA123"). As a result, the server obtains the code file and user ID as output.

[0228] Step 3:

[0229] The server reads the code file and passes its contents to the analysis engine. The input is the code file (e.g. "example.py") obtained by the server. The server reads the file and forwards it to the analysis engine. The output is the code file sent to the analysis engine.

[0230] Step 4:

[0231] The analysis engine analyzes the contents of a code file and identifies errors and areas for improvement. The input is a code file (e.g., "example.py") transferred from the server. The analysis engine checks the code based on standard programming rules and company-specific rules, and identifies errors (e.g., "inappropriate variable names") and areas for improvement (e.g., "too many unnecessary comments"). The output is the analysis results sent back to the server.

[0232] Step 5:

[0233] The server associates the analysis results received from the analysis engine with the user ID and saves them in a database. The input is the analysis results and the user ID. The server associates the analysis results with the user ID (e.g., "UserA123") and saves them in the database, storing them in a format that is easy for the user to retrieve again. The output is the analysis results saved in the database.

[0234] Step 6:

[0235] When the user checks the analysis results, the emotion engine recognizes the user's emotions and adjusts the way feedback is presented. The inputs are the user's facial expressions, tone of voice, and input data. The emotion engine analyzes this data and recognizes the user's emotions (e.g., feeling stressed). The output is the way feedback is presented.

[0236] Step 7:

[0237] When the user clicks the "Check Results" button on the device, the analysis results are sent back from the server and displayed on the device. The input is the analysis results stored on the server and the user's request. The device retrieves the analysis results and displays them to the user in a format adjusted by the emotion engine. The output is the feedback presented to the user.

[0238] The above is the specific processing flow of the program of this system.

[0239] (Application example 2)

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

[0241] In recent years, the need for security log analysis has increased. However, manually checking logs for anomalies is time-consuming and stressful for employees. While automated analysis systems exist for detecting anomalies, few systems provide feedback that takes into account the user's emotional state. This makes it difficult for stressed employees to take appropriate action. Therefore, there is a need for a system that automatically analyzes log files uploaded by users and provides feedback based on their emotional state.

[0242] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for a user to upload a code file from a terminal, means for the server to receive the code file and transfer it to an analysis engine, means for the analysis engine to analyze the code file and identify errors and areas for improvement, means for returning the analysis results to the user, and means having an emotion engine that recognizes the user's emotions and presenting the analysis results in accordance with the user's emotional state. This makes it possible to automatically analyze log files uploaded by users and provide feedback in accordance with the user's emotional state.

[0243] "User" means an individual or organization that uses the system to upload code files and log files for analysis and operates a terminal.

[0244] "Terminal" refers to a hardware device used by a user, such as a computer, smartphone, or tablet.

[0245] "Code File" means a file containing program source code and log data uploaded by a User.

[0246] "Server" means the central system that receives data from users, forwards it to the analytics engine, and returns the results to users.

[0247] "Analysis Engine" means automated analysis software that analyzes uploaded code files and identifies errors and areas for improvement.

[0248] "Error locations" refer to errors or problems in the code file that the analysis engine detects.

[0249] "Improvements" are specific suggestions and corrections that the analysis engine suggests to improve the quality of your code files.

[0250] An "emotion engine" is software that recognizes and analyzes a user's emotions based on their facial expressions, tone of voice, input data, etc.

[0251] "Analysis results" refers to information about errors and areas for improvement obtained by the analysis engine when it analyzes a code file.

[0252] "Feedback" refers to a means of effectively conveying information to users, such as analysis results and explanations or instructions for improvement based on the user's emotional state.

[0253] This invention is a system in which users upload code files, including log files, from their own devices, and the server analyzes the contents and provides feedback. In particular, a feedback method using an emotion engine enables flexible responses according to the user's psychological state.

[0254] Overall system configuration

[0255] This system mainly consists of the following hardware and software:

[0256] Hardware: User devices (computers, smartphones, tablets, etc.), servers

[0257] Software: Analysis engine, emotion engine, HTTP communication library (e.g. Requests)

[0258] Processing flow

[0259] 1. User Action:

[0260] The user selects a specific log file or code file from their device and clicks the upload button to send the file to the server.

[0261] 2. Server Receipt and Analysis:

[0262] The server receives an HTTP request containing the file sent by the user and the user ID. The received file is transferred to the analysis engine, where its contents are analyzed. The analysis engine identifies errors and areas for improvement and sends the results back to the server. The analysis also takes into account company-specific rules.

[0263] 3. Storing results and sentiment analysis:

[0264] The server stores the analysis results in a database, linking them to the user's ID. The results are stored in an appropriate format so that the user can easily retrieve them again. Next, the emotion engine analyzes the user's emotions. The analysis uses the user's facial expressions, tone of voice, and input data.

[0265] 4. Providing Feedback:

[0266] When the user clicks the "Show Analysis Results" button, the server sends back the analysis results. At this time, the user's emotional state is taken into account based on the analysis results of the emotion engine. If the user is feeling stressed, the method and order of presentation of the analysis results will be adjusted to provide feedback that is easy for the user to receive.

[0267] Specific examples

[0268] For example, let's say an employee uploads a system log file to Security Log Checker Plus. When the employee clicks the upload button and specifies the file, the device sends the log file and the employee's ID to the server. The server receives the file and transfers its contents to the analysis engine. The analysis engine analyzes the log file and identifies specific abnormal behavior or security risks. The analysis results are sent back to the server, linked to the employee's ID, and stored in a database.

[0269] When the employee clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device. At this point, the emotion engine analyzes the employee's emotions, and if it determines that the employee is feeling stressed, it adjusts the presentation method and order of the analysis results to provide feedback in a format that is easy for the employee to understand.

[0270] Prompt Sentence Examples

[0271] Below is an example of an input prompt sentence to the generative AI model that requests analysis from the system.

[0272] You are the developer of a security log analysis system. You will analyze the log data uploaded by employees to detect anomalies and analyze employee sentiment. Write a Python program to provide gentle feedback to employees who are stressed and detailed feedback to employees who are not stressed.

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

[0274] Step 1:

[0275] The user selects a code file or log file from the terminal and clicks the upload button. The input here is the file selected by the user and the user ID. As output, the terminal generates an HTTP request containing this information and sends it to the server.

[0276] Step 2:

[0277] The server receives the HTTP request sent by the user. It receives the HTTP request as input and extracts the user ID and file from it. After extraction, it transfers the file contents to the analysis engine. It sends the file contents to the analysis engine as output.

[0278] Step 3:

[0279] The analysis engine analyzes the file contents received as input and identifies errors and areas for improvement. The analysis takes into account general program rules and company-specific rules. As output, it generates the analysis results and sends them back to the server.

[0280] Step 4:

[0281] The server associates the analysis results received from the analysis engine with the user ID and stores them in a database. The input is the analysis results and user ID, and the output is the saved data. When saving to the database, it converts the data into an appropriate format to make it easy to retrieve again.

[0282] Step 5:

[0283] The emotion engine analyzes the user's emotions. It receives the user's facial expressions, tone of voice, or other input data as input. The emotion engine processes and analyzes these data to identify the user's emotional state. It generates data on the user's emotional state as output.

[0284] Step 6:

[0285] When the user clicks the "Show Analysis Results" button, the server retrieves the analysis results from the database. The input is the user ID. Based on the retrieved analysis results, the server adjusts the feedback presentation method and order based on the emotional state obtained from the emotion engine. As output, the analysis results are displayed to the user in an appropriate format.

[0286] Here are some specific examples:

[0287] The prompt might be something like this:

[0288] You are the developer of a security log analysis system. You will analyze the log data uploaded by employees to detect anomalies and analyze employee sentiment. Write a Python program to provide gentle feedback to employees who are stressed and detailed feedback to employees who are not stressed.

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

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

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

[0292] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

[0303] In the smart glasses 214, 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.

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

[0305] The present invention begins with the user uploading a code file from their device. The user launches the application on their device, clicks the "Upload" button, selects the code file, and sends it to the server. The device then generates an HTTP request and sends the user ID along with the code file to the server.

[0306] The server analyzes the received HTTP request, extracts the code file and user ID, then reads the code file and passes its contents to the analysis engine, which analyzes the contents of the code file and identifies errors and areas for improvement.

[0307] The analysis engine checks the code according to not only standard programming rules but also company-specific rules, enabling code reviews to be performed in accordance with company- or project-specific guidelines, improving quality. Once the analysis is complete, the analysis engine sends the results back to the server.

[0308] The server stores the analysis results received from the analysis engine in a database. To make it easier for users to retrieve the analysis results, the analysis results are managed in association with the user ID. If the user wants to check the analysis results again later, they can send a request from their device to the server and retrieve the analysis results.

[0309] As a concrete example, consider the case where User A uploads a Python code file called "example.py" to "Code Review Plus." When User A clicks the upload button and specifies the file, the device sends the file and User A's ID to the server. The server receives the file and transfers the contents to the analysis engine. The analysis engine analyzes "example.py" and finds specific errors and areas for improvement. The results are sent back to the server and stored in a database linked to User A's ID. When User A clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device.

[0310] This will enable User A to undergo code reviews at their own pace without experiencing interpersonal stress, improving the quality of their code, and significantly reducing the human costs and time required for reviews.

[0311] The processing flow will be explained below.

[0312] Step 1:

[0313] A user launches the application on their device, selects a code file, and clicks the "Upload" button. The device generates an HTTP request containing the selected code file and the user ID and sends it to the server.

[0314] Step 2:

[0315] The server receives the HTTP request, analyzes the request, extracts the code file and the user ID, and temporarily stores the received code file in preparation for analysis.

[0316] Step 3:

[0317] The server passes the contents of the code file to the analysis engine, which receives the code file transferred from the server and begins analyzing it.

[0318] Step 4:

[0319] The analysis engine analyzes the syntax of the code file, identifies errors and areas for improvement, checks the code against company-specific rules, and generates analysis results, which are then sent back to the server.

[0320] Step 5:

[0321] The server receives the analysis results, associates them with the user ID, and stores them in the database, allowing the user to check the results later.

[0322] Step 6:

[0323] The user clicks the "Show analysis results" button. The device generates an HTTP request including the user ID and requests the server to retrieve the analysis results.

[0324] Step 7:

[0325] The server receives the HTTP request, retrieves the analysis results corresponding to the user ID from the database, and returns them to the device. The analysis results are displayed on the user's device.

[0326] Step 8:

[0327] Users can check the analysis results on their devices, correct their own code based on errors and improvements, and take action to improve the quality of their code.

[0328] Through these steps, users will be able to undergo code reviews efficiently and stress-free at their own pace. In addition, the link between the server and the analysis engine will automate the review process, reducing human costs and time.

[0329] Example 1

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

[0331] Conventional code analysis systems are limited to simply detecting syntax errors in code, and do not perform analysis based on company-specific coding rules, which is insufficient in terms of quality control.In addition, there is no mechanism for users to easily retrieve analysis results, making efficient code reviews difficult.

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

[0333] In this invention, the server includes: means for a user to upload a program file from an information processing device; means for the information processing device to send a HyperText Transfer Protocol request including the program file and identification information to the server; means for the server to receive the HyperText Transfer Protocol request and transfer the program file and identification information to an analysis engine; means for the analysis engine to analyze the program file according to normal programming rules and specific rules and identify errors and areas for improvement; means for saving the analysis results in a database and managing them linked to the identification information; means for the user to send a request from the information processing device to the server so that the user can re-obtain the analysis results as needed; and means for the server to receive the request, obtain the analysis results from the database, and send them to the information processing device. This enables detailed code analysis based on company-specific rules and allows users to easily re-obtain the analysis results, thereby achieving efficient code review and quality control.

[0334] "User" means any person or entity that uses the System to upload Program Files.

[0335] An "information processing device" refers to a device used by a user, such as a computer or smartphone.

[0336] "Program File" means a file containing code uploaded by a User.

[0337] "Identifying Information" means data that includes a user's ID or other identifiable information.

[0338] "Hypertext Transfer Protocol Request" means a standardized protocol used to send and receive data between an information processing device and a server.

[0339] "Server" refers to a computer system that has the function of receiving requests sent by users and linking them to an analysis engine.

[0340] An "analysis engine" is software that analyzes program files and identifies errors and areas for improvement.

[0341] "Normal programming practices" refers to common coding style and standard programming rules.

[0342] "Specific rules" are special coding rules established by a company or a specific project.

[0343] "Analysis results" refers to information about errors and areas for improvement obtained by the analysis engine when it analyzes a program file.

[0344] A "database" is a digital storage system for storing analysis results.

[0345] A "request" is a request sent by a user to a server to retrieve analysis results.

[0346] The present invention relates to a system that allows a user to upload a program file from their own information processing device, analyze the file using an analysis engine, identify errors and areas for improvement, and manage and reacquire the analysis results.

[0347] First, a user launches the application using an information processing device (such as a computer or smartphone) and clicks the "Upload" button. The user then selects a program file (e.g., example.py) to upload from their local disk. At this time, the information processing device generates a Hypertext Transfer Protocol (HTTP) request containing the selected program file and the user's identification information (e.g., user123) and sends it to the server.

[0348] The server analyzes the incoming HTTP request and extracts the program file and user identification information. The server then temporarily stores the file and transfers its contents to the analysis engine. The analysis engine then performs a detailed analysis of the code according to standard programming rules and company-specific rules. For example, it identifies errors and areas for improvement, such as syntax errors, undefined variables, and areas that need refactoring.

[0349] Once the analysis is complete, the analysis engine returns the results in JSON format to the server. The server saves these analysis results in a database and manages them linked to the user's identification information. This allows the user to check the analysis results again later. When the user clicks the "Check Results" button, a request to re-acquire the results is sent from the information processing device to the server. The server retrieves the analysis results from the database and returns them to the information processing device. The information processing device displays the returned analysis results to the user.

[0350] Examples:

[0351] We will explain the case where User A uploads a Python code file "example.py" and obtains the analysis results. User A starts the application and clicks the "Upload" button to specify the file "example.py." The information processing device generates an HTTP request containing this file and User A's identification information and sends it to the server. The server receives the request, temporarily saves the file, and then transfers the contents to the analysis engine. The analysis engine analyzes the file, identifies errors and areas for improvement, and returns the results to the server. The server saves the analysis results in a database and links them to User A's identification information. When User A clicks the "Check Results" button, the server retrieves the results from the database and returns them to the information processing device for display.

[0352] Example prompt sentence:

[0353] A user wants to upload a Python code file, "example.py," for code review. The system begins when the user launches the application on their device and presses the "Upload" button to send the code file to the server. An HTTP request containing the user ID and code file is generated and sent to the server. The server parses the request and extracts the code file and user ID. The server then passes the code file to an analysis engine, which analyzes it, taking into account company-specific rules, to identify errors and areas for improvement. The analysis results are sent back to the server and stored in a database. When the user sends a request from their device to the server to view the analysis results, the server retrieves the results from the database and sends them back to the device. The device displays the analysis results to the user. Please explain this process in detail.

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

[0355] Step 1:

[0356] The user launches the application on the terminal. The user clicks the "Upload" button in the application and selects a program file (e.g., example.py) from the local disk. This operation specifies the program file to be uploaded and performs input operations related to that file.

[0357] Step 2:

[0358] The terminal generates an HTTP POST request containing the program file and user ID selected by the user. This request converts the data of the program file (example.py) and user ID (user123) into HyperText Transfer Protocol format and prepares it for transmission to the server.

[0359] Step 3:

[0360] The server analyzes the HTTP POST request received from the terminal. The server extracts the program file (example.py) and user ID (user123) from the request. In this analysis step, data analysis processing is performed to understand the data structure of the request and extract the necessary information.

[0361] Step 4:

[0362] The server saves the extracted program file in a temporary storage area. Next, it reads the contents of the program file and passes the data to the analysis engine. This read and transfer operation is a data transfer process that temporarily stores the file contents and passes them to the analysis engine.

[0363] Step 5:

[0364] The analysis engine analyzes the received program files and identifies errors and areas for improvement based on standard programming rules and company-specific rules. This analysis process involves syntactic analysis of the code in the program files and data analysis to identify errors and violations of coding rules.

[0365] Step 6:

[0366] Once the analysis is complete, the analysis engine returns the analysis results in JSON format to the server. This return operation is a data communication process that converts the analysis results into a structured data format and sends it to the server.

[0367] Step 7:

[0368] The server saves the analysis results in JSON format received from the analysis engine in a database. The server manages the analysis results by linking them to the user ID (user123). This saving and management operation is a database operation that registers the analysis results in a database (e.g., MySQL) so that they can be referenced later.

[0369] Step 8:

[0370] The user sends a request from the device to the server to check the analysis results. The device generates an HTTP GET request such as " / getResults?userID=user123" and sends it to the server. This operation is a data transfer process for generating and sending a data re-acquisition request.

[0371] Step 9:

[0372] The server analyzes the received HTTP GET request and retrieves the analysis results associated with the user ID from the database. This retrieval operation is a database access process that searches for and retrieves the required data from the database.

[0373] Step 10:

[0374] The server sends the acquired analysis results to the terminal as an HTTP response. The terminal displays the received analysis results to the user. This display operation is a data display process that visually presents the analysis results to the user.

[0375] (Application example 1)

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

[0377] In conventional code review systems, developers upload code in a local environment and check the results later, but real-time feedback is not available, which reduces development efficiency. Additionally, in specialized environments such as factories, it is difficult to point out program errors and areas for improvement in a timely manner, making it difficult to improve program quality.

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

[0379] In this invention, the server includes a means for users to upload code files from their terminals, a means for the server to receive the code files and transfer them to an analysis engine, a means for the analysis engine to analyze the code files and identify errors and areas for improvement, a means for returning the analysis results to the user, and a means for being directly installed on machines installed in a factory. This allows machines in a factory to identify errors and areas for improvement in program code in real time and display immediate feedback. Furthermore, the analysis results can be saved and retrieved and displayed as needed, improving development efficiency and maintaining quality.

[0380] "Code File" means a file containing program code created by a User.

[0381] "Terminal" refers to a device operated by a user, including smartphones, tablets, computers, etc.

[0382] "Server" means a networked computer system that receives uploaded code files, transmits them to the analysis engine, and manages the analysis results.

[0383] "Analysis Engine" means software or algorithms that analyze the contents of code files and identify errors and areas for improvement.

[0384] "Error locations" refer to defects or problems in the program code that are discovered when the analysis engine analyzes the code file.

[0385] "Improvements" refer to areas that the analysis engine determines, through analysis of the code file, require correction.

[0386] "Analysis Results" refers to information about errors and areas for improvement generated by the analysis engine after analyzing a code file.

[0387] "Machinery installed in a factory" refers to robots, equipment, etc. that are actually operating and operated within the factory.

[0388] "Display in real time" means that the analysis results are immediately reflected on the display device.

[0389] "Display device" refers to a device installed on a machine or terminal in a factory, which visually displays analysis results and other information.

[0390] "Means for returning to user" refers to the communication means for sending the analysis results back to the user's terminal or factory machine.

[0391] "Factory-specific rules" refers to the unique programming guidelines and standards that operate within a particular factory or company.

[0392] "Means for storing analysis results" refers to the methods and technologies for recording analysis results in storage such as a database.

[0393] This invention relates to a system that allows users to upload code files from a terminal and check the analysis results. This system is particularly applicable to machines installed in factories, and is capable of identifying code errors and areas for improvement in real time and displaying feedback.

[0394] First, a user uploads a code file using a dedicated application on a device such as a smartphone or computer. The device generates an HTTP request and sends the code file along with the user ID to the server. This allows the server to receive the code file and transfer it to the analysis engine.

[0395] The server then passes the received code files to an analysis engine, which analyzes the code based on normal programming rules and factory-specific rules to identify errors and areas for improvement. This analysis engine may include machine learning models or rule-based engines.

[0396] Once the analysis is complete, the server stores the results received from the analysis engine in a database, which stores the analysis results associated with each user ID.

[0397] Machines installed in factories are equipped with displays to display the analysis results. These displays retrieve the analysis results from the server as needed and provide feedback to the user in real time. Machines can frequently check for program errors and areas for improvement while they are operating, allowing for prompt corrections.

[0398] For example, when Robot A operating in a factory uploads a new control code file "control_script.py," Robot A can display the analysis results in real time on a display on the spot. For example, an error such as "Syntax error: Missing closing parenthesis (line 23)" is displayed, allowing the developer to take immediate action.

[0399] Examples of prompts to input to a generative AI model include:

[0400] "Please describe an application that automatically detects syntax errors and areas for improvement in the control code of machines installed in a factory, and displays feedback in real time. Please also show how to implement it using Python code, including specific functions and execution examples."

[0401] This invention allows factory equipment to check program code in real time and instantly display the analysis results, which is expected to significantly improve development efficiency and program code quality.

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

[0403] Step 1:

[0404] The terminal uploads the code file selected by the user. The user launches the terminal application and clicks the "Upload" button to select the code file. The selected file and the user ID are sent to the server via an HTTP request.

[0405] Input: User selected code file, User ID

[0406] Data manipulation: Combine the code file and user ID in the HTTP request

[0407] Output: HTTP request sent to the server

[0408] Step 2:

[0409] The server parses the received HTTP request and extracts the code file and user ID, which are then passed to the parsing engine.

[0410] Input: HTTP request (code file, user ID)

[0411] Data processing: Parsing HTTP requests, extracting code files and user IDs

[0412] Output: A code file that is passed to the analysis engine.

[0413] Step 3:

[0414] The analysis engine analyzes the received code file, following normal programming rules and factory-specific rules to identify errors and areas for improvement.

[0415] Input: Code file

[0416] Data processing: analyzing the code, identifying errors and areas for improvement

[0417] Output: Analysis results (errors, improvements)

[0418] Step 4:

[0419] The server stores the analysis results received from the analysis engine in a database, where they are linked to the user ID.

[0420] Input: Analysis results, user ID

[0421] Data processing: Analysis results are saved based on user ID.

[0422] Output: Analysis results stored in a database

[0423] Step 5:

[0424] When a user sends a request to check the analysis results from a terminal or a machine installed in a factory, the server retrieves the stored analysis results and returns them to the user.

[0425] Input: User request

[0426] Data processing: Search and extract saved analysis results

[0427] Output: Returning analysis results to user terminal or machine display

[0428] Step 6:

[0429] The analysis results are displayed in real time on the displays of the machines installed in the factory, allowing users to immediately check for errors and areas for improvement.

[0430] Input: Analysis results

[0431] Data processing: Display analysis results on the screen

[0432] Output: Feedback to the user

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

[0434] The present invention begins with the user uploading a code file from their device. The user launches the application on their device, selects the code file, and clicks the "Upload" button. The device then generates an HTTP request containing the selected code file and the user ID and sends it to the server.

[0435] The server analyzes the received HTTP request and extracts the code file and user ID. It then reads the code file and passes its contents to the analysis engine. The analysis engine analyzes the contents of the code file and identifies errors and areas for improvement. The analysis engine checks the code based on not only standard programming rules but also company-specific rules. Once the analysis is complete, it sends the results back to the server.

[0436] The server stores the analysis results received from the analysis engine in a database, linking them to the user ID. The analysis results are stored in an appropriate format so that users can easily retrieve them again.

[0437] The present invention further includes an emotion engine that recognizes the user's emotions. When the user displays the analysis results, the emotion engine analyzes the user's emotions based on their facial expressions, tone of voice, or input data. Based on the analyzed emotions, the emotion engine adjusts the presentation method and order of the analysis results. This reduces user stress and provides more effective feedback.

[0438] As a concrete example, consider the case where User A uploads his / her Python code "example.py" to "Code Review Plus." When User A clicks the upload button and specifies a file, the device sends the file and User A's ID to the server. The server receives the file and transfers its contents to the analysis engine. The analysis engine analyzes "example.py" and finds specific errors and areas for improvement. The analysis results are sent back to the server and stored in a database linked to User A's ID.

[0439] When User A clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device. At this point, the emotion engine analyzes User A's emotions, and if it determines that User A is feeling stressed, it adjusts the presentation method and order of the analysis results to provide feedback in a format that is easy for User A to understand.

[0440] This allows User A to undergo code reviews at their own pace without experiencing interpersonal stress and improve the quality of their code. The introduction of an emotion engine also provides customized feedback based on each user's psychological state, enabling more effective learning and improvement. It also significantly reduces the human costs and time required for reviews.

[0441] By recognizing user sentiment and providing analysis results based on it, this system will be able to provide a better user experience than traditional code review systems.

[0442] The processing flow will be explained below.

[0443] Step 1:

[0444] A user launches the application on their device, selects a code file, and clicks the "Upload" button. The device generates an HTTP request containing the selected code file and the user ID and sends it to the server.

[0445] Step 2:

[0446] The server receives the HTTP request, analyzes the request, extracts the code file and the user ID, and temporarily stores the received code file in preparation for analysis.

[0447] Step 3:

[0448] The server passes the contents of the code file to the analysis engine, which receives the code file transferred from the server and begins analyzing it.

[0449] Step 4:

[0450] The analysis engine analyzes the syntax of the code file, identifies errors and areas for improvement, performs checks including company-specific rules, and generates analysis results, which are then sent back to the server.

[0451] Step 5:

[0452] The server receives the analysis results, associates them with the user ID, and stores them in the database, allowing the user to check the results later.

[0453] Step 6:

[0454] The user clicks the "Show analysis results" button. The device generates an HTTP request including the user ID and requests the server to retrieve the analysis results.

[0455] Step 7:

[0456] The server receives the HTTP request, retrieves the analysis results corresponding to the user ID from the database, and returns them to the device. The analysis results are displayed on the user's device.

[0457] Step 8:

[0458] The emotion engine collects data (facial expressions, tone of voice, input data, etc.) to analyze the user's emotions. The user's emotions are analyzed based on this data.

[0459] Step 9:

[0460] The emotion engine adjusts the presentation and order of analysis results based on the user's emotions. The order in which analysis results are displayed and the content of feedback can be customized to reduce stress.

[0461] Step 10:

[0462] Users can check the analysis results on their devices, correct their own code based on errors and improvements, and take action to improve the quality of their code.

[0463] Through these steps, users can undergo code reviews efficiently and stress-free at their own pace, and by customizing the analysis results using the emotion engine, they can receive more effective feedback.

[0464] Example 2

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

[0466] Current code review systems primarily check code based on general programming rules and do not address company-specific rules. Furthermore, when users receive information about errors or improvements, there is no mechanism to present the information in an easy-to-understand format, which can increase user stress. This makes it difficult to effectively improve code quality, and the user experience during the review process is not improved.

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

[0468] In this invention, the server includes means for a user to upload a code file from a terminal, means for the server to receive the code file and transfer it to an analysis engine, means for the analysis engine to analyze the code file and identify errors and areas for improvement, means for returning the analysis results to the user, and means for the emotion engine to recognize the user's emotions and adjust the way in which the analysis results are presented. This makes it possible to comply with company-specific rules and provide effective feedback while reducing user stress.

[0469] "User" refers to an individual or corporation that uses the system.

[0470] "Terminal" refers to a device used by a user, such as a computer or smartphone.

[0471] A "code file" refers to a file in which the source code of a program is written.

[0472] A "server" refers to a computer system that receives and processes requests from users.

[0473] An "analysis engine" is a software system that analyzes code files and identifies errors and areas for improvement.

[0474] An "error location" refers to a part of a code file that causes the program to not function properly.

[0475] "Improvements" refer to areas of a code file that are recommended to be fixed in order to improve the quality of the program.

[0476] An "emotion engine" refers to a software system that recognizes a user's emotions and adjusts the way feedback is presented based on those emotions.

[0477] "Analysis results" refers to data containing information on errors and areas for improvement obtained by the analysis engine.

[0478] "Company-specific rules" refer to unique guidelines regarding programming and coding established by a particular company.

[0479] A "database" refers to a system for efficiently storing and managing data such as analysis results.

[0480] The present invention begins with a user uploading a code file from their device. Specifically, the user launches an application on their device, selects the code file they want to upload, and clicks the "Upload" button. This causes the device to generate an HTTP request containing the selected code file and their user ID and send it to the server.

[0481] The server analyzes the received HTTP request and extracts the code file and user ID. This process requires common server software and an analysis engine (e.g., a lint tool or custom analysis software). The server then reads the code file and passes it to the analysis engine. The analysis engine analyzes the contents of the code file and identifies errors and areas for improvement. The analysis engine checks the code based on standard programming rules as well as company-specific rules. Once the analysis is complete, the results are sent back to the server.

[0482] Next, the server stores the analysis results received from the analysis engine in a database, linking them to the user ID. When storing the results, the server stores them in a format that makes it easy for users to retrieve them again. This allows users to check past analysis results as needed.

[0483] The present invention further includes an emotion engine for recognizing a user's emotions. When a user displays analysis results, the emotion engine analyzes the user's emotions based on their facial expressions, tone of voice, and input data. Based on the analysis results, the presentation method and order of the analysis results are adjusted to reduce user stress. For example, if a user is feeling stressed, the user experience can be improved by presenting errors in order of ease.

[0484] As a concrete example, consider the case where User A uploads his or her own Python code "example.py." When User A clicks the "Upload" button and specifies the file, the device sends "example.py" and User A's ID to the server. The server receives the file and transfers its contents to the analysis engine. The analysis engine analyzes "example.py" and finds specific errors and areas for improvement. The analysis results are sent back to the server and stored in a database linked to User A's ID.

[0485] When User A clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device. At this time, the emotion engine analyzes User A's emotions, and if it determines that User A is feeling stressed, it adjusts the presentation method and order of the analysis results to provide feedback in a format that is easy for User A to understand.

[0486] An example of a prompt for the generative AI model in this system is:

[0487] "Please describe a system where users upload code files from their devices, and a server analyzes the files and points out errors and areas for improvement. Also, please detail the functionality that adjusts the way feedback is presented based on the user's emotions."

[0488] That's all.

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

[0490] Step 1:

[0491] The user launches the application on their device and selects the code file they want to upload. The input is the user-selected code file (e.g., "example.py") and their user ID. This action causes the device to generate an HTTP request containing the selected code file and their user ID and send it to the server as output.

[0492] Step 2:

[0493] The server analyzes the received HTTP request and extracts the code file and user ID. The input is the HTTP request sent from the terminal. The server first analyzes the request data and separates the code file (e.g., "example.py") and the user ID (e.g., "UserA123"). As a result, the server obtains the code file and user ID as output.

[0494] Step 3:

[0495] The server reads the code file and passes its contents to the analysis engine. The input is the code file (e.g. "example.py") obtained by the server. The server reads the file and forwards it to the analysis engine. The output is the code file sent to the analysis engine.

[0496] Step 4:

[0497] The analysis engine analyzes the contents of a code file and identifies errors and areas for improvement. The input is a code file (e.g., "example.py") transferred from the server. The analysis engine checks the code based on standard programming rules and company-specific rules, and identifies errors (e.g., "inappropriate variable names") and areas for improvement (e.g., "too many unnecessary comments"). The output is the analysis results sent back to the server.

[0498] Step 5:

[0499] The server associates the analysis results received from the analysis engine with the user ID and saves them in a database. The input is the analysis results and the user ID. The server associates the analysis results with the user ID (e.g., "UserA123") and saves them in the database, storing them in a format that is easy for the user to retrieve again. The output is the analysis results saved in the database.

[0500] Step 6:

[0501] When the user checks the analysis results, the emotion engine recognizes the user's emotions and adjusts the way feedback is presented. The inputs are the user's facial expressions, tone of voice, and input data. The emotion engine analyzes this data and recognizes the user's emotions (e.g., feeling stressed). The output is the way feedback is presented.

[0502] Step 7:

[0503] When the user clicks the "Check Results" button on the device, the analysis results are sent back from the server and displayed on the device. The input is the analysis results stored on the server and the user's request. The device retrieves the analysis results and displays them to the user in a format adjusted by the emotion engine. The output is the feedback presented to the user.

[0504] The above is the specific processing flow of the program of this system.

[0505] (Application example 2)

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

[0507] In recent years, the need for security log analysis has increased. However, manually checking logs for anomalies is time-consuming and stressful for employees. While automated analysis systems exist for detecting anomalies, few systems provide feedback that takes into account the user's emotional state. This makes it difficult for stressed employees to take appropriate action. Therefore, there is a need for a system that automatically analyzes log files uploaded by users and provides feedback based on their emotional state.

[0508] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for a user to upload a code file from a terminal, means for the server to receive the code file and transfer it to an analysis engine, means for the analysis engine to analyze the code file and identify errors and areas for improvement, means for returning the analysis results to the user, and means having an emotion engine that recognizes the user's emotions and presenting the analysis results in accordance with the user's emotional state. This makes it possible to automatically analyze log files uploaded by users and provide feedback in accordance with the user's emotional state.

[0509] "User" means an individual or organization that uses the system to upload code files and log files for analysis and operates a terminal.

[0510] "Terminal" refers to a hardware device used by a user, such as a computer, smartphone, or tablet.

[0511] "Code File" means a file containing program source code and log data uploaded by a User.

[0512] "Server" means the central system that receives data from users, forwards it to the analytics engine, and returns the results to users.

[0513] "Analysis Engine" means automated analysis software that analyzes uploaded code files and identifies errors and areas for improvement.

[0514] "Error locations" refer to errors or problems in the code file that the analysis engine detects.

[0515] "Improvements" are specific suggestions and corrections that the analysis engine suggests to improve the quality of your code files.

[0516] An "emotion engine" is software that recognizes and analyzes a user's emotions based on their facial expressions, tone of voice, input data, etc.

[0517] "Analysis results" refers to information about errors and areas for improvement obtained by the analysis engine when it analyzes a code file.

[0518] "Feedback" refers to a means of effectively conveying information to users, such as analysis results and explanations or instructions for improvement based on the user's emotional state.

[0519] This invention is a system in which users upload code files, including log files, from their own devices, and the server analyzes the contents and provides feedback. In particular, a feedback method using an emotion engine enables flexible responses according to the user's psychological state.

[0520] Overall system configuration

[0521] This system mainly consists of the following hardware and software:

[0522] Hardware: User devices (computers, smartphones, tablets, etc.), servers

[0523] Software: Analysis engine, emotion engine, HTTP communication library (e.g. Requests)

[0524] Processing flow

[0525] 1. User Action:

[0526] The user selects a specific log file or code file from their device and clicks the upload button to send the file to the server.

[0527] 2. Server Receipt and Analysis:

[0528] The server receives an HTTP request containing the file sent by the user and the user ID. The received file is transferred to the analysis engine, where its contents are analyzed. The analysis engine identifies errors and areas for improvement and sends the results back to the server. The analysis also takes into account company-specific rules.

[0529] 3. Storing results and sentiment analysis:

[0530] The server stores the analysis results in a database, linking them to the user's ID. The results are stored in an appropriate format so that the user can easily retrieve them again. Next, the emotion engine analyzes the user's emotions. The analysis uses the user's facial expressions, tone of voice, and input data.

[0531] 4. Providing Feedback:

[0532] When the user clicks the "Show Analysis Results" button, the server sends back the analysis results. At this time, the user's emotional state is taken into account based on the analysis results of the emotion engine. If the user is feeling stressed, the method and order of presentation of the analysis results will be adjusted to provide feedback that is easy for the user to receive.

[0533] Specific examples

[0534] For example, let's say an employee uploads a system log file to Security Log Checker Plus. When the employee clicks the upload button and specifies the file, the device sends the log file and the employee's ID to the server. The server receives the file and transfers its contents to the analysis engine. The analysis engine analyzes the log file and identifies specific abnormal behavior or security risks. The analysis results are sent back to the server, linked to the employee's ID, and stored in a database.

[0535] When the employee clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device. At this point, the emotion engine analyzes the employee's emotions, and if it determines that the employee is feeling stressed, it adjusts the presentation method and order of the analysis results to provide feedback in a format that is easy for the employee to understand.

[0536] Prompt Sentence Examples

[0537] Below is an example of an input prompt sentence to the generative AI model that requests analysis from the system.

[0538] You are the developer of a security log analysis system. You will analyze the log data uploaded by employees to detect anomalies and analyze employee sentiment. Write a Python program to provide gentle feedback to employees who are stressed and detailed feedback to employees who are not stressed.

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

[0540] Step 1:

[0541] The user selects a code file or log file from the terminal and clicks the upload button. The input here is the file selected by the user and the user ID. As output, the terminal generates an HTTP request containing this information and sends it to the server.

[0542] Step 2:

[0543] The server receives the HTTP request sent by the user. It receives the HTTP request as input and extracts the user ID and file from it. After extraction, it transfers the file contents to the analysis engine. It sends the file contents to the analysis engine as output.

[0544] Step 3:

[0545] The analysis engine analyzes the file contents received as input and identifies errors and areas for improvement. The analysis takes into account general program rules and company-specific rules. As output, it generates the analysis results and sends them back to the server.

[0546] Step 4:

[0547] The server associates the analysis results received from the analysis engine with the user ID and stores them in a database. The input is the analysis results and user ID, and the output is the saved data. When saving to the database, it converts the data into an appropriate format to make it easy to retrieve again.

[0548] Step 5:

[0549] The emotion engine analyzes the user's emotions. It receives the user's facial expressions, tone of voice, or other input data as input. The emotion engine processes and analyzes these data to identify the user's emotional state. It generates data on the user's emotional state as output.

[0550] Step 6:

[0551] When the user clicks the "Show Analysis Results" button, the server retrieves the analysis results from the database. The input is the user ID. Based on the retrieved analysis results, the server adjusts the feedback presentation method and order based on the emotional state obtained from the emotion engine. As output, the analysis results are displayed to the user in an appropriate format.

[0552] Here are some specific examples:

[0553] The prompt might be something like this:

[0554] You are the developer of a security log analysis system. You will analyze the log data uploaded by employees to detect anomalies and analyze employee sentiment. Write a Python program to provide gentle feedback to employees who are stressed and detailed feedback to employees who are not stressed.

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

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

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

[0558] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0571] The present invention begins with the user uploading a code file from their device. The user launches the application on their device, clicks the "Upload" button, selects the code file, and sends it to the server. The device then generates an HTTP request and sends the user ID along with the code file to the server.

[0572] The server analyzes the received HTTP request, extracts the code file and user ID, then reads the code file and passes its contents to the analysis engine, which analyzes the contents of the code file and identifies errors and areas for improvement.

[0573] The analysis engine checks the code according to not only standard programming rules but also company-specific rules, enabling code reviews to be performed in accordance with company- or project-specific guidelines, improving quality. Once the analysis is complete, the analysis engine sends the results back to the server.

[0574] The server stores the analysis results received from the analysis engine in a database. To make it easier for users to retrieve the analysis results, the analysis results are managed in association with the user ID. If the user wants to check the analysis results again later, they can send a request from their device to the server and retrieve the analysis results.

[0575] As a concrete example, consider the case where User A uploads a Python code file called "example.py" to "Code Review Plus." When User A clicks the upload button and specifies the file, the device sends the file and User A's ID to the server. The server receives the file and transfers the contents to the analysis engine. The analysis engine analyzes "example.py" and finds specific errors and areas for improvement. The results are sent back to the server and stored in a database linked to User A's ID. When User A clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device.

[0576] This will enable User A to undergo code reviews at their own pace without experiencing interpersonal stress, improving the quality of their code, and significantly reducing the human costs and time required for reviews.

[0577] The processing flow will be explained below.

[0578] Step 1:

[0579] A user launches the application on their device, selects a code file, and clicks the "Upload" button. The device generates an HTTP request containing the selected code file and the user ID and sends it to the server.

[0580] Step 2:

[0581] The server receives the HTTP request, analyzes the request, extracts the code file and the user ID, and temporarily stores the received code file in preparation for analysis.

[0582] Step 3:

[0583] The server passes the contents of the code file to the analysis engine, which receives the code file transferred from the server and begins analyzing it.

[0584] Step 4:

[0585] The analysis engine analyzes the syntax of the code file, identifies errors and areas for improvement, checks the code against company-specific rules, and generates analysis results, which are then sent back to the server.

[0586] Step 5:

[0587] The server receives the analysis results, associates them with the user ID, and stores them in the database, allowing the user to check the results later.

[0588] Step 6:

[0589] The user clicks the "Show analysis results" button. The device generates an HTTP request including the user ID and requests the server to retrieve the analysis results.

[0590] Step 7:

[0591] The server receives the HTTP request, retrieves the analysis results corresponding to the user ID from the database, and returns them to the device. The analysis results are displayed on the user's device.

[0592] Step 8:

[0593] Users can check the analysis results on their devices, correct their own code based on errors and areas for improvement, and take action to improve the quality of their code.

[0594] Through these steps, users will be able to undergo code reviews efficiently and stress-free at their own pace. In addition, the link between the server and the analysis engine will automate the review process, reducing human costs and time.

[0595] Example 1

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

[0597] Conventional code analysis systems are limited to simply detecting syntax errors in code, and do not perform analysis based on company-specific coding rules, which is insufficient in terms of quality control.In addition, there is no mechanism for users to easily retrieve analysis results, making efficient code reviews difficult.

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

[0599] In this invention, the server includes: means for a user to upload a program file from an information processing device; means for the information processing device to send a HyperText Transfer Protocol request including the program file and identification information to the server; means for the server to receive the HyperText Transfer Protocol request and transfer the program file and identification information to an analysis engine; means for the analysis engine to analyze the program file according to normal programming rules and specific rules and identify errors and areas for improvement; means for saving the analysis results in a database and managing them linked to the identification information; means for the user to send a request from the information processing device to the server so that the user can re-acquire the analysis results as needed; and means for the server to receive the request, retrieve the analysis results from the database, and send them to the information processing device. This enables detailed code analysis based on company-specific rules and allows users to easily re-acquire the analysis results, thereby achieving efficient code review and quality control.

[0600] "User" means any person or entity that uses the System to upload Program Files.

[0601] An "information processing device" refers to a device used by a user, such as a computer or smartphone.

[0602] "Program File" means a file containing code uploaded by a User.

[0603] "Identifying Information" means data that includes a user's ID or other identifiable information.

[0604] "Hypertext Transfer Protocol Request" means a standardized protocol used to send and receive data between information processing devices and servers.

[0605] "Server" refers to a computer system that has the function of receiving requests sent by users and linking them to an analysis engine.

[0606] An "analysis engine" is software that analyzes program files and identifies errors and areas for improvement.

[0607] "Normal programming practices" refers to common coding style and standard programming rules.

[0608] "Specific rules" are special coding rules established by a company or a specific project.

[0609] "Analysis results" refers to information about errors and areas for improvement obtained by the analysis engine when it analyzes a program file.

[0610] A "database" is a digital storage system for storing analysis results.

[0611] A "request" is a request sent by a user to a server to retrieve analysis results.

[0612] The present invention relates to a system that allows a user to upload a program file from their own information processing device, analyze the file using an analysis engine, identify errors and areas for improvement, and manage and reacquire the analysis results.

[0613] First, a user launches the application using an information processing device (such as a computer or smartphone) and clicks the "Upload" button. The user then selects a program file (e.g., example.py) to upload from their local disk. At this time, the information processing device generates a Hypertext Transfer Protocol (HTTP) request containing the selected program file and the user's identification information (e.g., user123) and sends it to the server.

[0614] The server analyzes the incoming HTTP request and extracts the program file and user identification information. The server then temporarily stores the file and transfers its contents to the analysis engine. The analysis engine then performs a detailed analysis of the code according to standard programming rules and company-specific rules. For example, it identifies errors and areas for improvement, such as syntax errors, undefined variables, and areas that need refactoring.

[0615] Once the analysis is complete, the analysis engine returns the results in JSON format to the server. The server saves these analysis results in a database and manages them linked to the user's identification information. This allows the user to check the analysis results again later. When the user clicks the "Check Results" button, a request to re-acquire the results is sent from the information processing device to the server. The server retrieves the analysis results from the database and returns them to the information processing device. The information processing device displays the returned analysis results to the user.

[0616] Examples:

[0617] We will explain the case where User A uploads a Python code file "example.py" and obtains the analysis results. User A starts the application and clicks the "Upload" button to specify the file "example.py." The information processing device generates an HTTP request containing this file and User A's identification information and sends it to the server. The server receives the request, temporarily saves the file, and then transfers the contents to the analysis engine. The analysis engine analyzes the file, identifies errors and areas for improvement, and returns the results to the server. The server saves the analysis results in a database and links them to User A's identification information. When User A clicks the "Check Results" button, the server retrieves the results from the database and returns them to the information processing device for display.

[0618] Example prompt sentence:

[0619] A user wants to upload a Python code file, "example.py," for code review. The system begins when the user launches the application on their device and presses the "Upload" button to send the code file to the server. An HTTP request containing the user ID and code file is generated and sent to the server. The server parses the request and extracts the code file and user ID. The server then passes the code file to an analysis engine, which analyzes it, taking into account company-specific rules, to identify errors and areas for improvement. The analysis results are sent back to the server and stored in a database. When the user sends a request from their device to the server to view the analysis results, the server retrieves the results from the database and sends them back to the device. The device displays the analysis results to the user. Please explain this process in detail.

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

[0621] Step 1:

[0622] The user launches the application on the terminal. The user clicks the "Upload" button in the application and selects a program file (e.g., example.py) from the local disk. This operation specifies the program file to be uploaded and performs input operations related to that file.

[0623] Step 2:

[0624] The terminal generates an HTTP POST request containing the program file and user ID selected by the user. This request converts the data of the program file (example.py) and user ID (user123) into HyperText Transfer Protocol format and prepares it for transmission to the server.

[0625] Step 3:

[0626] The server analyzes the HTTP POST request received from the terminal. The server extracts the program file (example.py) and user ID (user123) from the request. In this analysis step, data analysis processing is performed to understand the data structure of the request and extract the necessary information.

[0627] Step 4:

[0628] The server saves the extracted program file in a temporary storage area. Next, it reads the contents of the program file and passes the data to the analysis engine. This read and transfer operation is a data transfer process that temporarily stores the file contents and passes them to the analysis engine.

[0629] Step 5:

[0630] The analysis engine analyzes the received program files and identifies errors and areas for improvement based on standard programming rules and company-specific rules. This analysis process involves syntactic analysis of the code in the program files and data analysis to identify errors and violations of coding rules.

[0631] Step 6:

[0632] Once the analysis is complete, the analysis engine returns the analysis results in JSON format to the server. This return operation is a data communication process that converts the analysis results into a structured data format and sends it to the server.

[0633] Step 7:

[0634] The server saves the analysis results in JSON format received from the analysis engine in a database. The server manages the analysis results by linking them to the user ID (user123). This saving and management operation is a database operation that registers the analysis results in a database (e.g., MySQL) so that they can be referenced later.

[0635] Step 8:

[0636] The user sends a request from the device to the server to check the analysis results. The device generates an HTTP GET request such as " / getResults?userID=user123" and sends it to the server. This operation is a data transfer process for generating and sending a data re-acquisition request.

[0637] Step 9:

[0638] The server analyzes the received HTTP GET request and retrieves the analysis results associated with the user ID from the database. This retrieval operation is a database access process that searches for and retrieves the required data from the database.

[0639] Step 10:

[0640] The server sends the acquired analysis results to the terminal as an HTTP response. The terminal displays the received analysis results to the user. This display operation is a data display process that visually presents the analysis results to the user.

[0641] (Application example 1)

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

[0643] In conventional code review systems, developers upload code in a local environment and check the results later, but real-time feedback is not available, which reduces development efficiency. Additionally, in specialized environments such as factories, it is difficult to point out program errors and areas for improvement in a timely manner, making it difficult to improve program quality.

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

[0645] In this invention, the server includes a means for users to upload code files from their terminals, a means for the server to receive the code files and transfer them to an analysis engine, a means for the analysis engine to analyze the code files and identify errors and areas for improvement, a means for returning the analysis results to the user, and a means for being directly installed on machines installed in a factory. This allows machines in a factory to identify errors and areas for improvement in program code in real time and display immediate feedback. Furthermore, the analysis results can be saved and retrieved and displayed as needed, improving development efficiency and maintaining quality.

[0646] "Code File" means a file containing program code created by a User.

[0647] "Terminal" refers to a device operated by a user, including smartphones, tablets, computers, etc.

[0648] "Server" means a networked computer system that receives uploaded code files, transmits them to the analysis engine, and manages the analysis results.

[0649] "Analysis Engine" means software or algorithms that analyze the contents of code files and identify errors and areas for improvement.

[0650] "Error locations" refer to defects or problems in the program code that are discovered when the analysis engine analyzes the code file.

[0651] "Improvements" refer to areas that the analysis engine determines, through analysis of the code file, require correction.

[0652] "Analysis Results" refers to information about errors and areas for improvement generated by the analysis engine after analyzing a code file.

[0653] "Machinery installed in a factory" refers to robots, equipment, etc. that are actually operating and operated within the factory.

[0654] "Display in real time" means that the analysis results are immediately reflected on the display device.

[0655] "Display device" refers to a device installed on a machine or terminal in a factory, which visually displays analysis results and other information.

[0656] "Means for returning to user" refers to the communication means for sending the analysis results back to the user's terminal or factory machine.

[0657] "Factory-specific rules" refers to the unique programming guidelines and standards that operate within a particular factory or company.

[0658] "Means for storing analysis results" refers to the methods and technologies for recording analysis results in storage such as a database.

[0659] This invention relates to a system that allows users to upload code files from a terminal and check the analysis results. This system is particularly applicable to machines installed in factories, and is capable of identifying code errors and areas for improvement in real time and displaying feedback.

[0660] First, a user uploads a code file using a dedicated application on a device such as a smartphone or computer. The device generates an HTTP request and sends the code file along with the user ID to the server. This allows the server to receive the code file and transfer it to the analysis engine.

[0661] The server then passes the received code files to an analysis engine, which analyzes the code based on normal programming rules and factory-specific rules to identify errors and areas for improvement. This analysis engine may include machine learning models or rule-based engines.

[0662] Once the analysis is complete, the server stores the results received from the analysis engine in a database, which stores the analysis results associated with each user ID.

[0663] Machines installed in factories are equipped with displays to display the analysis results. These displays retrieve the analysis results from the server as needed and provide feedback to the user in real time. Machines can frequently check for program errors and areas for improvement while they are operating, allowing for prompt corrections.

[0664] For example, when Robot A operating in a factory uploads a new control code file "control_script.py," Robot A can display the analysis results in real time on a display on the spot. For example, an error such as "Syntax error: Missing closing parenthesis (line 23)" is displayed, allowing the developer to take immediate action.

[0665] Examples of prompts to input to a generative AI model include:

[0666] "Please describe an application that automatically detects syntax errors and areas for improvement in the control code of machines installed in a factory, and displays feedback in real time. Please also show how to implement it using Python code, including specific functions and execution examples."

[0667] This invention allows factory equipment to check program code in real time and instantly display the analysis results, which is expected to significantly improve development efficiency and program code quality.

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

[0669] Step 1:

[0670] The terminal uploads the code file selected by the user. The user launches the terminal application and clicks the "Upload" button to select the code file. The selected file and the user ID are sent to the server via an HTTP request.

[0671] Input: User selected code file, User ID

[0672] Data manipulation: Combine the code file and user ID in the HTTP request

[0673] Output: HTTP request sent to the server

[0674] Step 2:

[0675] The server parses the received HTTP request and extracts the code file and user ID, which are then passed to the parsing engine.

[0676] Input: HTTP request (code file, user ID)

[0677] Data processing: Parsing HTTP requests, extracting code files and user IDs

[0678] Output: A code file that is passed to the analysis engine.

[0679] Step 3:

[0680] The analysis engine analyzes the received code file, following normal programming rules and factory-specific rules to identify errors and areas for improvement.

[0681] Input: Code file

[0682] Data processing: analyzing the code, identifying errors and areas for improvement

[0683] Output: Analysis results (errors, improvements)

[0684] Step 4:

[0685] The server stores the analysis results received from the analysis engine in a database, where they are linked to the user ID.

[0686] Input: Analysis results, user ID

[0687] Data processing: Analysis results are saved based on user ID.

[0688] Output: Analysis results stored in a database

[0689] Step 5:

[0690] When a user sends a request to check the analysis results from a terminal or a machine installed in a factory, the server retrieves the stored analysis results and returns them to the user.

[0691] Input: User request

[0692] Data processing: Search and extract saved analysis results

[0693] Output: Returning analysis results to user terminal or machine display

[0694] Step 6:

[0695] The analysis results are displayed in real time on the displays of the machines installed in the factory, allowing users to immediately check for errors and areas for improvement.

[0696] Input: Analysis results

[0697] Data processing: Display analysis results on the screen

[0698] Output: Feedback to the user

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

[0700] The present invention begins with the user uploading a code file from their device. The user launches the application on their device, selects the code file, and clicks the "Upload" button. The device then generates an HTTP request containing the selected code file and the user ID and sends it to the server.

[0701] The server analyzes the received HTTP request and extracts the code file and user ID. It then reads the code file and passes its contents to the analysis engine. The analysis engine analyzes the contents of the code file and identifies errors and areas for improvement. The analysis engine checks the code based on not only standard programming rules but also company-specific rules. Once the analysis is complete, it sends the results back to the server.

[0702] The server stores the analysis results received from the analysis engine in a database, linking them to the user ID. The analysis results are stored in an appropriate format to make it easy for users to retrieve them again.

[0703] The present invention further includes an emotion engine that recognizes the user's emotions. When the user displays the analysis results, the emotion engine analyzes the user's emotions based on their facial expressions, tone of voice, or input data. Based on the analyzed emotions, the emotion engine adjusts the presentation method and order of the analysis results. This reduces user stress and provides more effective feedback.

[0704] As a concrete example, consider the case where User A uploads his / her Python code "example.py" to "Code Review Plus." When User A clicks the upload button and specifies a file, the device sends the file and User A's ID to the server. The server receives the file and transfers its contents to the analysis engine. The analysis engine analyzes "example.py" and finds specific errors and areas for improvement. The analysis results are sent back to the server and stored in a database linked to User A's ID.

[0705] When User A clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device. At this point, the emotion engine analyzes User A's emotions, and if it determines that User A is feeling stressed, it adjusts the presentation method and order of the analysis results to provide feedback in a format that is easy for User A to understand.

[0706] This allows User A to undergo code reviews at their own pace without experiencing interpersonal stress and improve the quality of their code. The introduction of an emotion engine also provides customized feedback based on each user's psychological state, enabling more effective learning and improvement. It also significantly reduces the human costs and time required for reviews.

[0707] By recognizing user sentiment and providing analysis results based on it, this system will be able to provide a better user experience than traditional code review systems.

[0708] The processing flow will be explained below.

[0709] Step 1:

[0710] A user launches the application on their device, selects a code file, and clicks the "Upload" button. The device generates an HTTP request containing the selected code file and the user ID and sends it to the server.

[0711] Step 2:

[0712] The server receives the HTTP request, analyzes the request, extracts the code file and the user ID, and temporarily stores the received code file in preparation for analysis.

[0713] Step 3:

[0714] The server passes the contents of the code file to the analysis engine, which receives the code file transferred from the server and begins analyzing it.

[0715] Step 4:

[0716] The analysis engine analyzes the syntax of the code file, identifies errors and areas for improvement, performs checks including company-specific rules, and generates analysis results, which are then sent back to the server.

[0717] Step 5:

[0718] The server receives the analysis results, associates them with the user ID, and stores them in the database, allowing the user to check the results later.

[0719] Step 6:

[0720] The user clicks the "Show analysis results" button. The device generates an HTTP request including the user ID and requests the server to retrieve the analysis results.

[0721] Step 7:

[0722] The server receives the HTTP request, retrieves the analysis results corresponding to the user ID from the database, and returns them to the device. The analysis results are displayed on the user's device.

[0723] Step 8:

[0724] The emotion engine collects data (facial expressions, tone of voice, input data, etc.) to analyze the user's emotions. The user's emotions are analyzed based on this data.

[0725] Step 9:

[0726] The emotion engine adjusts the presentation and order of analysis results based on the user's emotions. The order in which analysis results are displayed and the content of feedback can be customized to reduce stress.

[0727] Step 10:

[0728] Users can check the analysis results on their devices, correct their own code based on errors and improvements, and take action to improve the quality of their code.

[0729] Through these steps, users can undergo code reviews efficiently and stress-free at their own pace, and by customizing the analysis results using the emotion engine, they can receive more effective feedback.

[0730] Example 2

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

[0732] Current code review systems primarily check code based on general programming rules and do not address company-specific rules. Furthermore, when users receive information about errors or improvements, there is no mechanism to present the information in an easy-to-understand format, which can increase user stress. This makes it difficult to effectively improve code quality, and the user experience during the review process is not improved.

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

[0734] In this invention, the server includes means for a user to upload a code file from a terminal, means for the server to receive the code file and transfer it to an analysis engine, means for the analysis engine to analyze the code file and identify errors and areas for improvement, means for returning the analysis results to the user, and means for the emotion engine to recognize the user's emotions and adjust the way in which the analysis results are presented. This makes it possible to comply with company-specific rules and provide effective feedback while reducing user stress.

[0735] "User" refers to an individual or corporation that uses the system.

[0736] "Terminal" refers to a device used by a user, such as a computer or smartphone.

[0737] A "code file" refers to a file in which the source code of a program is written.

[0738] A "server" refers to a computer system that receives and processes requests from users.

[0739] An "analysis engine" is a software system that analyzes code files and identifies errors and areas for improvement.

[0740] An "error location" refers to a part of a code file that causes the program to not function properly.

[0741] "Improvements" refer to areas of a code file that are recommended to be fixed in order to improve the quality of the program.

[0742] An "emotion engine" refers to a software system that recognizes a user's emotions and adjusts the way feedback is presented based on those emotions.

[0743] "Analysis results" refers to data containing information on errors and areas for improvement obtained by the analysis engine.

[0744] "Company-specific rules" refer to unique guidelines regarding programming and coding established by a particular company.

[0745] A "database" refers to a system for efficiently storing and managing data such as analysis results.

[0746] The present invention begins with a user uploading a code file from their device. Specifically, the user launches an application on their device, selects the code file they want to upload, and clicks the "Upload" button. This causes the device to generate an HTTP request containing the selected code file and their user ID and send it to the server.

[0747] The server analyzes the received HTTP request and extracts the code file and user ID. This process requires common server software and an analysis engine (e.g., a lint tool or custom analysis software). The server then reads the code file and passes it to the analysis engine. The analysis engine analyzes the contents of the code file and identifies errors and areas for improvement. The analysis engine checks the code based on standard programming rules as well as company-specific rules. Once the analysis is complete, the results are sent back to the server.

[0748] Next, the server stores the analysis results received from the analysis engine in a database, linking them to the user ID. When storing the results, the server stores them in a format that makes it easy for users to retrieve them again. This allows users to check past analysis results as needed.

[0749] The present invention further includes an emotion engine for recognizing a user's emotions. When a user displays analysis results, the emotion engine analyzes the user's emotions based on their facial expressions, tone of voice, and input data. Based on the analysis results, the presentation method and order of the analysis results are adjusted to reduce user stress. For example, if a user is feeling stressed, the user experience can be improved by presenting errors in order of ease.

[0750] As a concrete example, consider the case where User A uploads his or her own Python code "example.py." When User A clicks the "Upload" button and specifies the file, the device sends "example.py" and User A's ID to the server. The server receives the file and transfers its contents to the analysis engine. The analysis engine analyzes "example.py" and finds specific errors and areas for improvement. The analysis results are sent back to the server and stored in a database linked to User A's ID.

[0751] When User A clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device. At this time, the emotion engine analyzes User A's emotions, and if it determines that User A is feeling stressed, it adjusts the presentation method and order of the analysis results to provide feedback in a format that is easy for User A to understand.

[0752] An example of a prompt for the generative AI model in this system is:

[0753] "Please describe a system where users upload code files from their devices, and a server analyzes the files and points out errors and areas for improvement. Also, please detail the functionality that adjusts the way feedback is presented based on the user's emotions."

[0754] That's all.

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

[0756] Step 1:

[0757] The user launches the application on their device and selects the code file they want to upload. The input is the user-selected code file (e.g., "example.py") and their user ID. This action causes the device to generate an HTTP request containing the selected code file and their user ID and send it to the server as output.

[0758] Step 2:

[0759] The server analyzes the received HTTP request and extracts the code file and user ID. The input is the HTTP request sent from the terminal. The server first analyzes the request data and separates the code file (e.g., "example.py") and the user ID (e.g., "UserA123"). As a result, the server obtains the code file and user ID as output.

[0760] Step 3:

[0761] The server reads the code file and passes its contents to the analysis engine. The input is the code file (e.g. "example.py") obtained by the server. The server reads the file and forwards it to the analysis engine. The output is the code file sent to the analysis engine.

[0762] Step 4:

[0763] The analysis engine analyzes the contents of a code file and identifies errors and areas for improvement. The input is a code file (e.g., "example.py") transferred from the server. The analysis engine checks the code based on standard programming rules and company-specific rules, and identifies errors (e.g., "inappropriate variable names") and areas for improvement (e.g., "too many unnecessary comments"). The output is the analysis results sent back to the server.

[0764] Step 5:

[0765] The server associates the analysis results received from the analysis engine with the user ID and saves them in a database. The input is the analysis results and the user ID. The server associates the analysis results with the user ID (e.g., "UserA123") and saves them in the database, storing them in a format that is easy for the user to retrieve again. The output is the analysis results saved in the database.

[0766] Step 6:

[0767] When the user checks the analysis results, the emotion engine recognizes the user's emotions and adjusts the way feedback is presented. The inputs are the user's facial expressions, tone of voice, and input data. The emotion engine analyzes this data and recognizes the user's emotions (e.g., feeling stressed). The output is the way feedback is presented.

[0768] Step 7:

[0769] When the user clicks the "Check Results" button on the device, the analysis results are sent back from the server and displayed on the device. The input is the analysis results stored on the server and the user's request. The device retrieves the analysis results and displays them to the user in a format adjusted by the emotion engine. The output is the feedback presented to the user.

[0770] The above is the specific processing flow of the program of this system.

[0771] (Application example 2)

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

[0773] In recent years, the need for security log analysis has increased. However, manually checking logs for anomalies is time-consuming and stressful for employees. While automated analysis systems exist for detecting anomalies, few systems provide feedback that takes into account the user's emotional state. This makes it difficult for stressed employees to take appropriate action. Therefore, there is a need for a system that automatically analyzes log files uploaded by users and provides feedback based on their emotional state.

[0774] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for a user to upload a code file from a terminal, means for the server to receive the code file and transfer it to an analysis engine, means for the analysis engine to analyze the code file and identify errors and areas for improvement, means for returning the analysis results to the user, and means having an emotion engine that recognizes the user's emotions and presenting the analysis results in accordance with the user's emotional state. This makes it possible to automatically analyze log files uploaded by users and provide feedback in accordance with the user's emotional state.

[0775] "User" means an individual or organization that uses the system to upload code files and log files for analysis and operates a terminal.

[0776] "Terminal" refers to a hardware device used by a user, such as a computer, smartphone, or tablet.

[0777] "Code File" means a file containing program source code and log data uploaded by a User.

[0778] "Server" means the central system that receives data from users, forwards it to the analytics engine, and returns the results to users.

[0779] "Analysis Engine" means automated analysis software that analyzes uploaded code files and identifies errors and areas for improvement.

[0780] "Error locations" refer to errors or problems in the code file that the analysis engine detects.

[0781] "Improvements" are specific suggestions and corrections that the analysis engine suggests to improve the quality of your code files.

[0782] An "emotion engine" is software that recognizes and analyzes a user's emotions based on their facial expressions, tone of voice, input data, etc.

[0783] "Analysis results" refers to information about errors and areas for improvement obtained by the analysis engine when it analyzes a code file.

[0784] "Feedback" refers to a means of effectively conveying information to users, such as analysis results and explanations or instructions for improvement based on the user's emotional state.

[0785] This invention is a system in which users upload code files, including log files, from their own devices, and the server analyzes the contents and provides feedback. In particular, a feedback method using an emotion engine enables flexible responses according to the user's psychological state.

[0786] Overall system configuration

[0787] This system mainly consists of the following hardware and software:

[0788] Hardware: User devices (computers, smartphones, tablets, etc.), servers

[0789] Software: Analysis engine, emotion engine, HTTP communication library (e.g. Requests)

[0790] Processing flow

[0791] 1. User Action:

[0792] The user selects a specific log file or code file from their device and clicks the upload button to send the file to the server.

[0793] 2. Server Receipt and Analysis:

[0794] The server receives an HTTP request containing the file sent by the user and the user ID. The received file is transferred to the analysis engine, where its contents are analyzed. The analysis engine identifies errors and areas for improvement and sends the results back to the server. The analysis also takes into account company-specific rules.

[0795] 3. Storing results and sentiment analysis:

[0796] The server stores the analysis results in a database, linking them to the user's ID. The results are stored in an appropriate format so that the user can easily retrieve them again. Next, the emotion engine analyzes the user's emotions. The analysis uses the user's facial expressions, tone of voice, and input data.

[0797] 4. Providing Feedback:

[0798] When the user clicks the "Show Analysis Results" button, the server sends back the analysis results. At this time, the user's emotional state is taken into account based on the analysis results of the emotion engine. If the user is feeling stressed, the method and order of presentation of the analysis results will be adjusted to provide feedback that is easy for the user to receive.

[0799] Specific examples

[0800] For example, let's say an employee uploads a system log file to Security Log Checker Plus. When the employee clicks the upload button and specifies the file, the device sends the log file and the employee's ID to the server. The server receives the file and transfers its contents to the analysis engine. The analysis engine analyzes the log file and identifies specific abnormal behavior or security risks. The analysis results are sent back to the server, linked to the employee's ID, and stored in a database.

[0801] When the employee clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device. At this point, the emotion engine analyzes the employee's emotions, and if it determines that the employee is feeling stressed, it adjusts the presentation method and order of the analysis results to provide feedback in a format that is easy for the employee to understand.

[0802] Prompt Sentence Examples

[0803] Below is an example of an input prompt sentence to the generative AI model that requests analysis from the system.

[0804] You are the developer of a security log analysis system. You will analyze the log data uploaded by employees to detect anomalies and analyze employee sentiment. Write a Python program to provide gentle feedback to employees who are stressed and detailed feedback to employees who are not stressed.

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

[0806] Step 1:

[0807] The user selects a code file or log file from the terminal and clicks the upload button. The input here is the file selected by the user and the user ID. As output, the terminal generates an HTTP request containing this information and sends it to the server.

[0808] Step 2:

[0809] The server receives the HTTP request sent by the user. It receives the HTTP request as input and extracts the user ID and file from it. After extraction, it transfers the file contents to the analysis engine. It sends the file contents to the analysis engine as output.

[0810] Step 3:

[0811] The analysis engine analyzes the file contents received as input and identifies errors and areas for improvement. The analysis takes into account general program rules and company-specific rules. As output, it generates the analysis results and sends them back to the server.

[0812] Step 4:

[0813] The server associates the analysis results received from the analysis engine with the user ID and stores them in a database. The input is the analysis results and user ID, and the output is the saved data. When saving to the database, it converts the data into an appropriate format to make it easy to retrieve again.

[0814] Step 5:

[0815] The emotion engine analyzes the user's emotions. It receives the user's facial expressions, tone of voice, or other input data as input. The emotion engine processes and analyzes these data to identify the user's emotional state. It generates data on the user's emotional state as output.

[0816] Step 6:

[0817] When the user clicks the "Show Analysis Results" button, the server retrieves the analysis results from the database. The input is the user ID. Based on the retrieved analysis results, the server adjusts the feedback presentation method and order based on the emotional state obtained from the emotion engine. As output, the analysis results are displayed to the user in an appropriate format.

[0818] Here are some specific examples:

[0819] The prompt might be something like this:

[0820] You are the developer of a security log analysis system. You will analyze the log data uploaded by employees to detect anomalies and analyze employee sentiment. Write a Python program to provide gentle feedback to employees who are stressed and detailed feedback to employees who are not stressed.

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

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

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

[0824] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[0838] The present invention begins with the user uploading a code file from their device. The user launches the application on their device, clicks the "Upload" button, selects the code file, and sends it to the server. The device then generates an HTTP request and sends the user ID along with the code file to the server.

[0839] The server analyzes the received HTTP request, extracts the code file and user ID, then reads the code file and passes its contents to the analysis engine, which analyzes the contents of the code file and identifies errors and areas for improvement.

[0840] The analysis engine checks the code according to not only standard programming rules but also company-specific rules, enabling code reviews to be performed in accordance with company- or project-specific guidelines, improving quality. Once the analysis is complete, the analysis engine sends the results back to the server.

[0841] The server stores the analysis results received from the analysis engine in a database. To make it easier for users to retrieve the analysis results, the analysis results are managed in association with the user ID. If the user wants to check the analysis results again later, they can send a request from their device to the server and retrieve the analysis results.

[0842] As a concrete example, consider the case where User A uploads a Python code file called "example.py" to "Code Review Plus." When User A clicks the upload button and specifies the file, the device sends the file and User A's ID to the server. The server receives the file and transfers the contents to the analysis engine. The analysis engine analyzes "example.py" and finds specific errors and areas for improvement. The results are sent back to the server and stored in a database linked to User A's ID. When User A clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device.

[0843] This will enable User A to undergo code reviews at their own pace without experiencing interpersonal stress, improving the quality of their code, and significantly reducing the human costs and time required for reviews.

[0844] The processing flow will be explained below.

[0845] Step 1:

[0846] A user launches the application on their device, selects a code file, and clicks the "Upload" button. The device generates an HTTP request containing the selected code file and the user ID and sends it to the server.

[0847] Step 2:

[0848] The server receives the HTTP request, analyzes the request, extracts the code file and the user ID, and temporarily stores the received code file in preparation for analysis.

[0849] Step 3:

[0850] The server passes the contents of the code file to the analysis engine, which receives the code file transferred from the server and begins analyzing it.

[0851] Step 4:

[0852] The analysis engine analyzes the syntax of the code file, identifies errors and areas for improvement, checks the code against company-specific rules, and generates analysis results, which are then sent back to the server.

[0853] Step 5:

[0854] The server receives the analysis results, associates them with the user ID, and stores them in the database, allowing the user to check the results later.

[0855] Step 6:

[0856] The user clicks the "Show analysis results" button. The device generates an HTTP request including the user ID and requests the server to retrieve the analysis results.

[0857] Step 7:

[0858] The server receives the HTTP request, retrieves the analysis results corresponding to the user ID from the database, and returns them to the device. The analysis results are displayed on the user's device.

[0859] Step 8:

[0860] Users can check the analysis results on their devices, correct their own code based on errors and areas for improvement, and take action to improve the quality of their code.

[0861] Through these steps, users will be able to undergo code reviews efficiently and stress-free at their own pace. In addition, the link between the server and the analysis engine will automate the review process, reducing human costs and time.

[0862] Example 1

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

[0864] Conventional code analysis systems are limited to simply detecting syntax errors in code, and do not perform analysis based on company-specific coding rules, which is insufficient in terms of quality control.In addition, there is no mechanism for users to easily retrieve analysis results, making efficient code reviews difficult.

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

[0866] In this invention, the server includes: means for a user to upload a program file from an information processing device; means for the information processing device to send a HyperText Transfer Protocol request including the program file and identification information to the server; means for the server to receive the HyperText Transfer Protocol request and transfer the program file and identification information to an analysis engine; means for the analysis engine to analyze the program file according to normal programming rules and specific rules and identify errors and areas for improvement; means for saving the analysis results in a database and managing them linked to the identification information; means for the user to send a request from the information processing device to the server so that the user can re-acquire the analysis results as needed; and means for the server to receive the request, retrieve the analysis results from the database, and send them to the information processing device. This enables detailed code analysis based on company-specific rules and allows users to easily re-acquire the analysis results, thereby achieving efficient code review and quality control.

[0867] "User" means any person or entity that uses the System to upload Program Files.

[0868] An "information processing device" refers to a device used by a user, such as a computer or smartphone.

[0869] "Program File" means a file containing code uploaded by a User.

[0870] "Identifying Information" means data that includes a user's ID or other identifiable information.

[0871] "Hypertext Transfer Protocol Request" means a standardized protocol used to send and receive data between information processing devices and servers.

[0872] "Server" refers to a computer system that has the function of receiving requests sent by users and linking them to an analysis engine.

[0873] An "analysis engine" is software that analyzes program files and identifies errors and areas for improvement.

[0874] "Normal programming practices" refers to common coding style and standard programming rules.

[0875] "Specific rules" are special coding rules established by a company or a specific project.

[0876] "Analysis results" refers to information about errors and areas for improvement obtained by the analysis engine when it analyzes a program file.

[0877] A "database" is a digital storage system for storing analysis results.

[0878] A "request" is a request sent by a user to a server to retrieve analysis results.

[0879] The present invention relates to a system that allows a user to upload a program file from their own information processing device, analyze the file using an analysis engine, identify errors and areas for improvement, and manage and reacquire the analysis results.

[0880] First, a user launches the application using an information processing device (such as a computer or smartphone) and clicks the "Upload" button. The user then selects a program file (e.g., example.py) to upload from their local disk. At this time, the information processing device generates a Hypertext Transfer Protocol (HTTP) request containing the selected program file and the user's identification information (e.g., user123) and sends it to the server.

[0881] The server analyzes the incoming HTTP request and extracts the program file and user identification information. The server then temporarily stores the file and transfers its contents to the analysis engine. The analysis engine then performs a detailed analysis of the code according to standard programming rules and company-specific rules. For example, it identifies errors and areas for improvement, such as syntax errors, undefined variables, and areas that need refactoring.

[0882] Once the analysis is complete, the analysis engine returns the results in JSON format to the server. The server saves these analysis results in a database and manages them linked to the user's identification information. This allows the user to check the analysis results again later. When the user clicks the "Check Results" button, a request to re-acquire the results is sent from the information processing device to the server. The server retrieves the analysis results from the database and returns them to the information processing device. The information processing device displays the returned analysis results to the user.

[0883] Examples:

[0884] We will explain the case where User A uploads a Python code file "example.py" and obtains the analysis results. User A starts the application and clicks the "Upload" button to specify the file "example.py." The information processing device generates an HTTP request containing this file and User A's identification information and sends it to the server. The server receives the request, temporarily saves the file, and then transfers the contents to the analysis engine. The analysis engine analyzes the file, identifies errors and areas for improvement, and returns the results to the server. The server saves the analysis results in a database and links them to User A's identification information. When User A clicks the "Check Results" button, the server retrieves the results from the database and returns them to the information processing device for display.

[0885] Example prompt sentence:

[0886] A user wants to upload a Python code file, "example.py," for code review. The system begins when the user launches the application on their device and presses the "Upload" button to send the code file to the server. An HTTP request containing the user ID and code file is generated and sent to the server. The server parses the request and extracts the code file and user ID. The server then passes the code file to an analysis engine, which analyzes it, taking into account company-specific rules, to identify errors and areas for improvement. The analysis results are sent back to the server and stored in a database. When the user sends a request from their device to the server to view the analysis results, the server retrieves the results from the database and sends them back to the device. The device displays the analysis results to the user. Please explain this process in detail.

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

[0888] Step 1:

[0889] The user launches the application on the terminal. The user clicks the "Upload" button in the application and selects a program file (e.g., example.py) from the local disk. This operation specifies the program file to be uploaded and performs input operations related to that file.

[0890] Step 2:

[0891] The terminal generates an HTTP POST request containing the program file and user ID selected by the user. This request converts the data of the program file (example.py) and user ID (user123) into HyperText Transfer Protocol format and prepares it for transmission to the server.

[0892] Step 3:

[0893] The server analyzes the HTTP POST request received from the terminal. The server extracts the program file (example.py) and user ID (user123) from the request. In this analysis step, data analysis processing is performed to understand the data structure of the request and extract the necessary information.

[0894] Step 4:

[0895] The server saves the extracted program file in a temporary storage area. Next, it reads the contents of the program file and passes the data to the analysis engine. This read and transfer operation is a data transfer process that temporarily stores the file contents and passes them to the analysis engine.

[0896] Step 5:

[0897] The analysis engine analyzes the received program files and identifies errors and areas for improvement based on standard programming rules and company-specific rules. This analysis process involves syntactic analysis of the code in the program files and data analysis to identify errors and violations of coding rules.

[0898] Step 6:

[0899] Once the analysis is complete, the analysis engine returns the analysis results in JSON format to the server. This return operation is a data communication process that converts the analysis results into a structured data format and sends it to the server.

[0900] Step 7:

[0901] The server saves the analysis results in JSON format received from the analysis engine in a database. The server manages the analysis results by linking them to the user ID (user123). This saving and management operation is a database operation that registers the analysis results in a database (e.g., MySQL) so that they can be referenced later.

[0902] Step 8:

[0903] The user sends a request from the device to the server to check the analysis results. The device generates an HTTP GET request such as " / getResults?userID=user123" and sends it to the server. This operation is a data transfer process for generating and sending a data re-acquisition request.

[0904] Step 9:

[0905] The server analyzes the received HTTP GET request and retrieves the analysis results associated with the user ID from the database. This retrieval operation is a database access process that searches for and retrieves the required data from the database.

[0906] Step 10:

[0907] The server sends the acquired analysis results to the terminal as an HTTP response. The terminal displays the received analysis results to the user. This display operation is a data display process that visually presents the analysis results to the user.

[0908] (Application example 1)

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

[0910] In conventional code review systems, developers upload code in a local environment and check the results later, but real-time feedback is not available, which reduces development efficiency. Additionally, in specialized environments such as factories, it is difficult to point out program errors and areas for improvement in a timely manner, making it difficult to improve program quality.

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

[0912] In this invention, the server includes a means for users to upload code files from their terminals, a means for the server to receive the code files and transfer them to an analysis engine, a means for the analysis engine to analyze the code files and identify errors and areas for improvement, a means for returning the analysis results to the user, and a means for being directly installed on machines installed in a factory. This allows machines in a factory to identify errors and areas for improvement in program code in real time and display immediate feedback. Furthermore, the analysis results can be saved and retrieved and displayed as needed, improving development efficiency and maintaining quality.

[0913] "Code File" means a file containing program code created by a User.

[0914] "Terminal" refers to a device operated by a user, including smartphones, tablets, computers, etc.

[0915] "Server" means a networked computer system that receives uploaded code files, transmits them to the analysis engine, and manages the analysis results.

[0916] "Analysis Engine" means software or algorithms that analyze the contents of code files and identify errors and areas for improvement.

[0917] "Error locations" refer to defects or problems in the program code that are discovered when the analysis engine analyzes the code file.

[0918] "Improvements" refer to areas that the analysis engine determines, through analysis of the code file, require correction.

[0919] "Analysis Results" refers to information about errors and areas for improvement generated by the analysis engine after analyzing a code file.

[0920] "Machinery installed in a factory" refers to robots, equipment, etc. that are actually operating and operated within the factory.

[0921] "Display in real time" means that the analysis results are immediately reflected on the display device.

[0922] "Display device" refers to a device installed on a machine or terminal in a factory, which visually displays analysis results and other information.

[0923] "Means for returning to user" refers to the communication means for sending the analysis results back to the user's terminal or factory machine.

[0924] "Factory-specific rules" refers to the unique programming guidelines and standards that operate within a particular factory or company.

[0925] "Means for storing analysis results" refers to the methods and technologies for recording analysis results in storage such as a database.

[0926] This invention relates to a system that allows users to upload code files from a terminal and check the analysis results. This system is particularly applicable to machines installed in factories, and is capable of identifying code errors and areas for improvement in real time and displaying feedback.

[0927] First, a user uploads a code file using a dedicated application on a device such as a smartphone or computer. The device generates an HTTP request and sends the code file along with the user ID to the server. This allows the server to receive the code file and transfer it to the analysis engine.

[0928] The server then passes the received code files to an analysis engine, which analyzes the code based on normal programming rules and factory-specific rules to identify errors and areas for improvement. This analysis engine may include machine learning models or rule-based engines.

[0929] Once the analysis is complete, the server stores the results received from the analysis engine in a database, which stores the analysis results associated with each user ID.

[0930] Machines installed in factories are equipped with displays to display the analysis results. These displays retrieve the analysis results from the server as needed and provide feedback to the user in real time. Machines can frequently check for program errors and areas for improvement while they are operating, allowing for prompt corrections.

[0931] For example, when Robot A operating in a factory uploads a new control code file "control_script.py," Robot A can display the analysis results in real time on a display on the spot. For example, an error such as "Syntax error: Missing closing parenthesis (line 23)" is displayed, allowing the developer to take immediate action.

[0932] Examples of prompts to input to a generative AI model include:

[0933] "Please describe an application that automatically detects syntax errors and areas for improvement in the control code of machines installed in a factory, and displays feedback in real time. Please also show how to implement it using Python code, including specific functions and execution examples."

[0934] This invention allows factory equipment to check program code in real time and instantly display the analysis results, which is expected to significantly improve development efficiency and program code quality.

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

[0936] Step 1:

[0937] The terminal uploads the code file selected by the user. The user launches the terminal application and clicks the "Upload" button to select the code file. The selected file and the user ID are sent to the server via an HTTP request.

[0938] Input: User selected code file, User ID

[0939] Data manipulation: Combine the code file and user ID in the HTTP request

[0940] Output: HTTP request sent to the server

[0941] Step 2:

[0942] The server parses the received HTTP request and extracts the code file and user ID, which are then passed to the parsing engine.

[0943] Input: HTTP request (code file, user ID)

[0944] Data processing: Parsing HTTP requests, extracting code files and user IDs

[0945] Output: A code file that is passed to the analysis engine.

[0946] Step 3:

[0947] The analysis engine analyzes the received code file, following normal programming rules and factory-specific rules to identify errors and areas for improvement.

[0948] Input: Code file

[0949] Data processing: analyzing the code, identifying errors and areas for improvement

[0950] Output: Analysis results (errors, improvements)

[0951] Step 4:

[0952] The server stores the analysis results received from the analysis engine in a database, where they are linked to the user ID.

[0953] Input: Analysis results, user ID

[0954] Data processing: Analysis results are saved based on user ID.

[0955] Output: Analysis results stored in a database

[0956] Step 5:

[0957] When a user sends a request to check the analysis results from a terminal or a machine installed in a factory, the server retrieves the stored analysis results and returns them to the user.

[0958] Input: User request

[0959] Data processing: Search and extract saved analysis results

[0960] Output: Returning analysis results to user terminal or machine display

[0961] Step 6:

[0962] The analysis results are displayed in real time on the displays of the machines installed in the factory, allowing users to immediately check for errors and areas for improvement.

[0963] Input: Analysis results

[0964] Data processing: Display analysis results on the screen

[0965] Output: Feedback to the user

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

[0967] The present invention begins with the user uploading a code file from their device. The user launches the application on their device, selects the code file, and clicks the "Upload" button. The device then generates an HTTP request containing the selected code file and the user ID and sends it to the server.

[0968] The server analyzes the received HTTP request and extracts the code file and user ID. It then reads the code file and passes its contents to the analysis engine. The analysis engine analyzes the contents of the code file and identifies errors and areas for improvement. The analysis engine checks the code based on not only standard programming rules but also company-specific rules. Once the analysis is complete, it sends the results back to the server.

[0969] The server stores the analysis results received from the analysis engine in a database, linking them to the user ID. The analysis results are stored in an appropriate format so that users can easily retrieve them again.

[0970] The present invention further includes an emotion engine that recognizes the user's emotions. When the user displays the analysis results, the emotion engine analyzes the user's emotions based on their facial expressions, tone of voice, or input data. Based on the analyzed emotions, the emotion engine adjusts the presentation method and order of the analysis results. This reduces user stress and provides more effective feedback.

[0971] As a concrete example, consider the case where User A uploads his / her Python code "example.py" to "Code Review Plus." When User A clicks the upload button and specifies a file, the device sends the file and User A's ID to the server. The server receives the file and transfers its contents to the analysis engine. The analysis engine analyzes "example.py" and finds specific errors and areas for improvement. The analysis results are sent back to the server and stored in a database linked to User A's ID.

[0972] When User A clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device. At this point, the emotion engine analyzes User A's emotions, and if it determines that User A is feeling stressed, it adjusts the presentation method and order of the analysis results to provide feedback in a format that is easy for User A to understand.

[0973] This allows User A to undergo code reviews at their own pace without experiencing interpersonal stress and improve the quality of their code. The introduction of an emotion engine also provides customized feedback based on each user's psychological state, enabling more effective learning and improvement. It also significantly reduces the human costs and time required for reviews.

[0974] By recognizing user sentiment and providing analysis results based on it, this system will be able to provide a better user experience than traditional code review systems.

[0975] The processing flow will be explained below.

[0976] Step 1:

[0977] A user launches the application on their device, selects a code file, and clicks the "Upload" button. The device generates an HTTP request containing the selected code file and the user ID and sends it to the server.

[0978] Step 2:

[0979] The server receives the HTTP request, analyzes the request, extracts the code file and the user ID, and temporarily stores the received code file in preparation for analysis.

[0980] Step 3:

[0981] The server passes the contents of the code file to the analysis engine, which receives the code file transferred from the server and begins analyzing it.

[0982] Step 4:

[0983] The analysis engine analyzes the syntax of the code file, identifies errors and areas for improvement, performs checks including company-specific rules, and generates analysis results, which are then sent back to the server.

[0984] Step 5:

[0985] The server receives the analysis results, associates them with the user ID, and stores them in the database, allowing the user to check the results later.

[0986] Step 6:

[0987] The user clicks the "Show analysis results" button. The device generates an HTTP request including the user ID and requests the server to retrieve the analysis results.

[0988] Step 7:

[0989] The server receives the HTTP request, retrieves the analysis results corresponding to the user ID from the database, and returns them to the device. The analysis results are displayed on the user's device.

[0990] Step 8:

[0991] The emotion engine collects data (facial expressions, tone of voice, input data, etc.) to analyze the user's emotions. The user's emotions are analyzed based on this data.

[0992] Step 9:

[0993] The emotion engine adjusts the presentation and order of analysis results based on the user's emotions. The order in which analysis results are displayed and the content of feedback can be customized to reduce stress.

[0994] Step 10:

[0995] Users can check the analysis results on their devices, correct their own code based on errors and areas for improvement, and take action to improve the quality of their code.

[0996] Through these steps, users can undergo code reviews efficiently and stress-free at their own pace, and by customizing the analysis results using the emotion engine, they can receive more effective feedback.

[0997] Example 2

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

[0999] Current code review systems primarily check code based on general programming rules and do not address company-specific rules. Furthermore, when users receive information about errors or improvements, there is no mechanism to present the information in an easy-to-understand format, which can increase user stress. This makes it difficult to effectively improve code quality, and the user experience during the review process is not improved.

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

[1001] In this invention, the server includes means for a user to upload a code file from a terminal, means for the server to receive the code file and transfer it to an analysis engine, means for the analysis engine to analyze the code file and identify errors and areas for improvement, means for returning the analysis results to the user, and means for the emotion engine to recognize the user's emotions and adjust the way in which the analysis results are presented. This makes it possible to comply with company-specific rules and provide effective feedback while reducing user stress.

[1002] "User" refers to an individual or corporation that uses the system.

[1003] "Terminal" refers to a device used by a user, such as a computer or smartphone.

[1004] A "code file" refers to a file in which the source code of a program is written.

[1005] A "server" refers to a computer system that receives and processes requests from users.

[1006] An "analysis engine" is a software system that analyzes code files and identifies errors and areas for improvement.

[1007] An "error location" refers to a part of a code file that causes the program to not function properly.

[1008] "Improvements" refer to areas of a code file that are recommended to be fixed in order to improve the quality of the program.

[1009] An "emotion engine" refers to a software system that recognizes a user's emotions and adjusts the way feedback is presented based on those emotions.

[1010] "Analysis results" refers to data containing information on errors and areas for improvement obtained by the analysis engine.

[1011] "Company-specific rules" refer to unique guidelines regarding programming and coding established by a particular company.

[1012] A "database" refers to a system for efficiently storing and managing data such as analysis results.

[1013] The present invention begins with a user uploading a code file from their device. Specifically, the user launches an application on their device, selects the code file they want to upload, and clicks the "Upload" button. This causes the device to generate an HTTP request containing the selected code file and their user ID and send it to the server.

[1014] The server analyzes the received HTTP request and extracts the code file and user ID. This process requires common server software and an analysis engine (e.g., a lint tool or custom analysis software). The server then reads the code file and passes it to the analysis engine. The analysis engine analyzes the contents of the code file and identifies errors and areas for improvement. The analysis engine checks the code based on standard programming rules as well as company-specific rules. Once the analysis is complete, the results are sent back to the server.

[1015] Next, the server stores the analysis results received from the analysis engine in a database, linking them to the user ID. When storing the results, the server stores them in a format that makes it easy for users to retrieve them again. This allows users to check past analysis results as needed.

[1016] The present invention further includes an emotion engine for recognizing a user's emotions. When a user displays analysis results, the emotion engine analyzes the user's emotions based on their facial expressions, tone of voice, and input data. Based on the analysis results, the presentation method and order of the analysis results are adjusted to reduce user stress. For example, if a user is feeling stressed, the user experience can be improved by presenting errors in order of ease.

[1017] As a concrete example, consider the case where User A uploads his or her own Python code "example.py." When User A clicks the "Upload" button and specifies the file, the device sends "example.py" and User A's ID to the server. The server receives the file and transfers its contents to the analysis engine. The analysis engine analyzes "example.py" and finds specific errors and areas for improvement. The analysis results are sent back to the server and stored in a database linked to User A's ID.

[1018] When User A clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device. At this time, the emotion engine analyzes User A's emotions, and if it determines that User A is feeling stressed, it adjusts the presentation method and order of the analysis results to provide feedback in a format that is easy for User A to understand.

[1019] An example of a prompt for the generative AI model in this system is:

[1020] "Please describe a system where users upload code files from their devices, and a server analyzes the files and points out errors and areas for improvement. Also, please detail the functionality that adjusts the way feedback is presented based on the user's emotions."

[1021] That's all.

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

[1023] Step 1:

[1024] The user launches the application on their device and selects the code file they want to upload. The input is the user-selected code file (e.g., "example.py") and their user ID. This action causes the device to generate an HTTP request containing the selected code file and their user ID and send it to the server as output.

[1025] Step 2:

[1026] The server analyzes the received HTTP request and extracts the code file and user ID. The input is the HTTP request sent from the terminal. The server first analyzes the request data and separates the code file (e.g., "example.py") and the user ID (e.g., "UserA123"). As a result, the server obtains the code file and user ID as output.

[1027] Step 3:

[1028] The server reads the code file and passes its contents to the analysis engine. The input is the code file (e.g. "example.py") obtained by the server. The server reads the file and forwards it to the analysis engine. The output is the code file sent to the analysis engine.

[1029] Step 4:

[1030] The analysis engine analyzes the contents of a code file and identifies errors and areas for improvement. The input is a code file (e.g., "example.py") transferred from the server. The analysis engine checks the code based on standard programming rules and company-specific rules, and identifies errors (e.g., "inappropriate variable names") and areas for improvement (e.g., "too many unnecessary comments"). The output is the analysis results sent back to the server.

[1031] Step 5:

[1032] The server associates the analysis results received from the analysis engine with the user ID and saves them in a database. The input is the analysis results and the user ID. The server associates the analysis results with the user ID (e.g., "UserA123") and saves them in the database, storing them in a format that is easy for the user to retrieve again. The output is the analysis results saved in the database.

[1033] Step 6:

[1034] When the user checks the analysis results, the emotion engine recognizes the user's emotions and adjusts the way feedback is presented. The inputs are the user's facial expressions, tone of voice, and input data. The emotion engine analyzes this data and recognizes the user's emotions (e.g., feeling stressed). The output is the way feedback is presented.

[1035] Step 7:

[1036] When the user clicks the "Check Results" button on the device, the analysis results are sent back from the server and displayed on the device. The input is the analysis results stored on the server and the user's request. The device retrieves the analysis results and displays them to the user in a format adjusted by the emotion engine. The output is the feedback presented to the user.

[1037] The above is the specific processing flow of the program of this system.

[1038] (Application example 2)

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

[1040] In recent years, the need for security log analysis has increased. However, manually checking logs for anomalies is time-consuming and stressful for employees. While automated analysis systems exist for detecting anomalies, few systems provide feedback that takes into account the user's emotional state. This makes it difficult for stressed employees to take appropriate action. Therefore, there is a need for a system that automatically analyzes log files uploaded by users and provides feedback based on their emotional state.

[1041] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for a user to upload a code file from a terminal, means for the server to receive the code file and transfer it to an analysis engine, means for the analysis engine to analyze the code file and identify errors and areas for improvement, means for returning the analysis results to the user, and means having an emotion engine that recognizes the user's emotions and presenting the analysis results in accordance with the user's emotional state. This makes it possible to automatically analyze log files uploaded by users and provide feedback in accordance with the user's emotional state.

[1042] "User" means an individual or organization that uses the system to upload code files and log files for analysis and operates a terminal.

[1043] "Terminal" refers to a hardware device used by a user, such as a computer, smartphone, or tablet.

[1044] "Code File" means a file containing program source code and log data uploaded by a User.

[1045] "Server" means the central system that receives data from users, forwards it to the analytics engine, and returns the results to users.

[1046] "Analysis Engine" means automated analysis software that analyzes uploaded code files and identifies errors and areas for improvement.

[1047] "Error locations" refer to errors or problems in the code file that the analysis engine detects.

[1048] "Improvements" are specific suggestions and corrections that the analysis engine suggests to improve the quality of your code files.

[1049] An "emotion engine" is software that recognizes and analyzes a user's emotions based on their facial expressions, tone of voice, input data, etc.

[1050] "Analysis results" refers to information about errors and areas for improvement obtained by the analysis engine when it analyzes a code file.

[1051] "Feedback" refers to a means of effectively conveying information to users, such as analysis results and explanations or instructions for improvement based on the user's emotional state.

[1052] This invention is a system in which users upload code files, including log files, from their own devices, and the server analyzes the contents and provides feedback. In particular, a feedback method using an emotion engine enables flexible responses according to the user's psychological state.

[1053] Overall system configuration

[1054] This system mainly consists of the following hardware and software:

[1055] Hardware: User devices (computers, smartphones, tablets, etc.), servers

[1056] Software: Analysis engine, emotion engine, HTTP communication library (e.g. Requests)

[1057] Processing flow

[1058] 1. User Action:

[1059] The user selects a specific log file or code file from their device and clicks the upload button to send the file to the server.

[1060] 2. Server Receipt and Analysis:

[1061] The server receives an HTTP request containing the file sent by the user and the user ID. The received file is transferred to the analysis engine, where its contents are analyzed. The analysis engine identifies errors and areas for improvement and sends the results back to the server. The analysis also takes into account company-specific rules.

[1062] 3. Storing results and sentiment analysis:

[1063] The server stores the analysis results in a database, linking them to the user's ID. The results are stored in an appropriate format so that the user can easily retrieve them again. Next, the emotion engine analyzes the user's emotions. The analysis uses the user's facial expressions, tone of voice, and input data.

[1064] 4. Providing Feedback:

[1065] When the user clicks the "Show Analysis Results" button, the server sends back the analysis results. At this time, the user's emotional state is taken into account based on the analysis results of the emotion engine. If the user is feeling stressed, the method and order of presentation of the analysis results will be adjusted to provide feedback that is easy for the user to receive.

[1066] Specific examples

[1067] For example, let's say an employee uploads a system log file to Security Log Checker Plus. When the employee clicks the upload button and specifies the file, the device sends the log file and the employee's ID to the server. The server receives the file and transfers its contents to the analysis engine. The analysis engine analyzes the log file and identifies specific abnormal behavior or security risks. The analysis results are sent back to the server, linked to the employee's ID, and stored in a database.

[1068] When the employee clicks the "Check Results" button, the analysis results are sent back from the server and displayed on the device. At this point, the emotion engine analyzes the employee's emotions, and if it determines that the employee is feeling stressed, it adjusts the presentation method and order of the analysis results to provide feedback in a format that is easy for the employee to understand.

[1069] Prompt Sentence Examples

[1070] Below is an example of an input prompt sentence to the generative AI model that requests analysis from the system.

[1071] You are the developer of a security log analysis system. You will analyze the log data uploaded by employees to detect anomalies and analyze employee sentiment. Write a Python program to provide gentle feedback to employees who are stressed and detailed feedback to employees who are not stressed.

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

[1073] Step 1:

[1074] The user selects a code file or log file from the terminal and clicks the upload button. The input here is the file selected by the user and the user ID. As output, the terminal generates an HTTP request containing this information and sends it to the server.

[1075] Step 2:

[1076] The server receives the HTTP request sent by the user. It receives the HTTP request as input and extracts the user ID and file from it. After extraction, it transfers the file contents to the analysis engine. It sends the file contents to the analysis engine as output.

[1077] Step 3:

[1078] The analysis engine analyzes the file contents received as input and identifies errors and areas for improvement. The analysis takes into account general program rules and company-specific rules. As output, it generates the analysis results and sends them back to the server.

[1079] Step 4:

[1080] The server associates the analysis results received from the analysis engine with the user ID and stores them in a database. The input is the analysis results and user ID, and the output is the saved data. When saving to the database, it converts the data into an appropriate format to make it easy to retrieve again.

[1081] Step 5:

[1082] The emotion engine analyzes the user's emotions. It receives the user's facial expressions, tone of voice, or other input data as input. The emotion engine processes and analyzes these data to identify the user's emotional state. It generates data on the user's emotional state as output.

[1083] Step 6:

[1084] When the user clicks the "Show Analysis Results" button, the server retrieves the analysis results from the database. The input is the user ID. Based on the retrieved analysis results, the server adjusts the feedback presentation method and order based on the emotional state obtained from the emotion engine. As output, the analysis results are displayed to the user in an appropriate format.

[1085] Here are some specific examples:

[1086] The prompt might be something like this:

[1087] You are the developer of a security log analysis system. You will analyze the log data uploaded by employees to detect anomalies and analyze employee sentiment. Write a Python program to provide gentle feedback to employees who are stressed and detailed feedback to employees who are not stressed.

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

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

[1090] 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 robot 414.

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

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

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

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

[1095] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

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

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

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

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

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

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

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

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

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

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

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

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

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

[1109] The following is further disclosed regarding the above embodiment.

[1110] (Claim 1)

[1111] A way for users to upload code files from their devices;

[1112] A server receives the code file and transfers it to an analysis engine;

[1113] An analysis engine analyzes the code file and identifies errors and areas for improvement;

[1114] means for returning the analysis results to the user;

[1115] A system including:

[1116] (Claim 2)

[1117] 10. The system of claim 1, further comprising means for analyzing the content of user-uploaded code files based on company-specific rules.

[1118] (Claim 3)

[1119] 2. The system according to claim 1, further comprising means for storing the analysis results in a database so that the results can be retrieved by the user as needed.

[1120] "Example 1"

[1121] (Claim 1)

[1122] A means for a user to upload a program file from an information processing device;

[1123] means for transmitting a hypertext transfer protocol request including the program file and the identification information to a server by an information processing device;

[1124] a server means for receiving the HyperText Transfer Protocol request and transmitting the program file and the identification information to an analysis engine;

[1125] An analysis engine analyzes the program file according to normal programming rules and specific rules to identify errors and areas for improvement;

[1126] a means for storing the analysis results in a database and managing them in association with identification information;

[1127] means for transmitting a request from the information processing device to the server so that the user can reacquire the analysis results as needed;

[1128] a server receiving the request, acquiring the analysis result from the database, and transmitting the result to the information processing device;

[1129] A system including:

[1130] (Claim 2)

[1131] 10. The system of claim 1, further comprising means for analyzing the content of program files uploaded by users based on company-specific rules.

[1132] (Claim 3)

[1133] 2. The system according to claim 1, further comprising means for managing the analysis results stored in the storage device and means for linking the results to user identification information so that the results can be retrieved again.

[1134] "Application Example 1"

[1135] (Claim 1)

[1136] A way for users to upload code files from their devices;

[1137] A server receives the code file and transfers it to an analysis engine;

[1138] An analysis engine analyzes the code file and identifies errors and areas for improvement;

[1139] means for returning the analysis results to the user;

[1140] means installed directly on the machine at the factory;

[1141] A system including:

[1142] (Claim 2)

[1143] 2. The system according to claim 1, further comprising means for analyzing the contents of the code file uploaded by the user based on company-specific rules and displaying the analysis results on the display device of the machine in real time.

[1144] (Claim 3)

[1145] 2. The system according to claim 1, further comprising means for storing the analysis results in a database and for the machine to automatically retrieve and display the analysis results as needed.

[1146] "Example 2: Combining Emotion Engines"

[1147] (Claim 1)

[1148] A means for a user to upload a code file from a device;

[1149] A server receives the code file and transfers it to an analysis engine;

[1150] An analysis engine analyzes the code file and identifies errors and areas for improvement;

[1151] means for returning the analysis results to a user;

[1152] a means for the emotion engine to recognize the user's emotions and adjust the presentation of the analysis results;

[1153] A system including:

[1154] (Claim 2)

[1155] 10. The system of claim 1, further comprising means for analyzing the content of a code file uploaded by a user based on company-specific rules.

[1156] (Claim 3)

[1157] 2. The system according to claim 1, further comprising means for storing the analysis results in a database so that the results can be retrieved by the user as needed.

[1158] "Application example 2 when combining emotion engines"

[1159] (Claim 1)

[1160] A way for users to upload code files from their devices;

[1161] A server receives the code file and transfers it to an analysis engine;

[1162] An analysis engine analyzes the code file and identifies errors and areas for improvement;

[1163] means for returning the analysis results to the user;

[1164] a means for providing an emotion engine that recognizes the emotion of a user and presenting the analysis result in accordance with the emotional state of the user;

[1165] A system including:

[1166] (Claim 2)

[1167] 10. The system of claim 1, further comprising means for analyzing the content of user-uploaded code files based on company-specific rules.

[1168] (Claim 3)

[1169] 2. The system according to claim 1, further comprising means for storing the analysis results in a database so that the results can be retrieved by the user as needed. [Explanation of symbols]

[1170] 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 for users to upload code files from their devices; A server receives the code file and transfers it to an analysis engine; An analysis engine analyzes the code file and identifies errors and areas for improvement; means for returning the analysis results to the user; A system including:

2. 10. The system of claim 1, further comprising: means for analyzing the content of a code file uploaded by a user based on company-specific rules.

3. The system according to claim 1 , further comprising means for storing the analysis results in a database so that the results can be retrieved by the user as needed.

Images