system

Abstract

Provide a system. [Solution] a means for collecting source code and design documentation; A means for analyzing the collected source code and design documents and extracting logic patterns; A means for saving the extracted logic patterns and comparing them with newly added logic patterns; A means for identifying similar logic patterns and notifying a user; A system including:

Description

[Technical Field]

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

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

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

[0004] In software development, when creating new code or designs, manually checking the similarity with existing code or design documents is time-consuming and labor-intensive. Furthermore, while leveraging similar implementations from the past can improve development efficiency, the search costs are high. Therefore, there is a need to promote the reuse of existing implementations in software development and reduce search costs. [Means for solving the problem]

[0005] The system includes a means for collecting source code and design documents, a means for analyzing the collected source code and design documents to extract logic patterns, a means for saving the extracted logic patterns and comparing them with newly added logic patterns, and a means for identifying similar logic patterns and notifying the user. The system also includes a means for generating and saving feature vectors of logic patterns using a machine learning model, and a means for users to search for specific logic patterns and display the results. This promotes the reuse of existing implementations in software development and reduces search costs.

[0006] "Source code" means computer program instructions written in a human-readable and writable form that describe the program's behavior.

[0007] A "design document" is a document that describes in detail the operation and structure of software, and indicates the design concept, specifications, and structural design.

[0008] A "collection means" is a means for obtaining source code and design documents from a specific location and storing them within the system.

[0009] "Analysis means" refers to a means for analyzing collected source code and design documents and extracting their internal structure and logic patterns.

[0010] "Extraction means" refers to a means for selecting and clarifying specific logic patterns from the analyzed information.

[0011] The "storage means" refers to a means for storing the extracted logic patterns and other analysis results in a database or storage within the system.

[0012] The "comparison means" is a means for comparing a saved logic pattern with a newly added pattern and determining the similarity.

[0013] The "identification means" is a means for selecting logic patterns with high similarity based on the collation results.

[0014] The "notification means" is a means for notifying the user of information about the identified similar pattern.

[0015] A "machine learning model" is a computational model that learns patterns from large amounts of data and uses them to determine the characteristics of new data.

[0016] A "feature vector" is vector-format data that numerically represents the characteristics of data in a machine learning model.

[0017] The "search means" is a means for searching the database and obtaining related information based on a user's query.

[0018] The "display means" is a means for visually displaying search results to the user. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0027] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0040] This system aims to improve development efficiency by utilizing existing logic patterns in software development. Below, we will explain the overview of the system and the specific processing flow.

[0041] System Overview

[0042] This system involves a server, a terminal, and a user. The server automatically collects, analyzes, and stores all source code and design documents in a database. The terminal provides an interface for users to access the system, receives user search queries, and communicates with the server.

[0043] Explaining program processing in natural language

[0044] 1. Data Collection

[0045] Server: Collects source code and design documents on a regular schedule, including accessing repositories and databases to detect recent changes.

[0046] Example: The server automatically accesses the repository at 10pm to get the latest state of the project.

[0047] 2. Data Analysis

[0048] Server: Parses the collected data and extracts logic patterns from each piece of code and design document. This includes identifying patterns such as function definitions, loop structures, and conditional branching.

[0049] Example: A server parses a Java file, extracts "try-catch" blocks and saves them as feature vectors.

[0050] 3. Pattern Matching

[0051] Server: Matches newly added data with logic patterns in the existing database, and calculates and identifies similarities.

[0052] Example: The server analyzes the for loop of a newly added Python script and calculates the similarity by comparing it with past similar patterns.

[0053] 4. Presentation of results

[0054] Server: Notifies the user of similar logic patterns, including the ability to provide the user with detailed information about the identified patterns.

[0055] Users: Receive notifications, view a list of results in the interface, and click on the details of identified logic patterns to get the information they need for further development.

[0056] Example: The server detects a similar pattern for the new login verification code for "Project A" and notifies the user, "Please refer to your past login verification codes."

[0057] 5. Search and Suggestions

[0058] User: When searching for a specific logic pattern, the user enters a query into the interface and sends it to the server.

[0059] Server: Receives queries, searches for relevant logic patterns in the database, and sends the results to the user in the form of a list.

[0060] User: Check the results and, if necessary, use the selected code and design documents to develop new ideas.

[0061] Example: A user searches for "database connection error handling," and the server returns a code list containing similar patterns from the past. The user can use this as a reference to create new error handling code.

[0062] This system allows developers to effectively utilize past implementations, reducing search costs and enabling efficient new development.

[0063] The processing flow will be explained below.

[0064] Step 1:

[0065] The server collects source code and design documents on a regular schedule, accessing repositories and databases to identify changed and newly added files, and then downloads these files to local storage and saves them in text format.

[0066] Step 2:

[0067] The server analyzes the collected source code and design documents. First, it uses a syntax analysis engine to parse the source code and extract each code structure (e.g., function, loop, conditional branch). The analysis results are organized in an internal data structure and identified as logic patterns.

[0068] Step 3:

[0069] The server converts the extracted logic patterns into templates and generates feature vectors. This involves quantifying the characteristics of each pattern and converting them into vector format. The generated feature vectors are stored in a database for machine learning.

[0070] Step 4:

[0071] The server analyzes newly added source code and design documents, compares the extracted logic patterns with the existing database, and uses a machine learning algorithm to calculate the similarity between the existing feature vector and the new feature vector.

[0072] Step 5:

[0073] The server identifies similar logic patterns based on the similarity score, and if the similarity exceeds a threshold, identifies the pattern and prepares the results in a list format.

[0074] Step 6:

[0075] The server notifies the user of a list of identified similar logic patterns, including links to relevant code snippets and design documents, and provides this information to the user through a user interface.

[0076] Step 7:

[0077] Users receive a notification and view a list of results in the interface. They can click on the details of identified similar logic patterns to view related information. This information can then be used as a reference for new code or designs to further their development.

[0078] Step 8:

[0079] When a user searches for a particular logic pattern, they enter a query into the interface, which is sent to the server, which searches for relevant logic patterns in its database.

[0080] Step 9:

[0081] The server generates a list of search results and returns them to the user via a user interface. The user can then refer to the results to find the code snippets or design documents they need.

[0082] This series of processes allows developers to efficiently reuse past implementations and reduce search costs in new development.

[0083] Example 1

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

[0085] In software development, a system capable of efficiently managing and appropriately searching a large number of source codes and design documents is required to effectively utilize existing logic patterns and improve development efficiency. However, conventional systems collect, analyze, and search source codes and design documents separately, and lack a consistent workflow, making it difficult to efficiently support development work. Furthermore, there is a lack of a means to quickly identify the similarities between newly added logic patterns and existing patterns and notify users, which prevents developers from effectively utilizing past implementations.

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

[0087] In this invention, the server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns as feature vectors, means for comparing newly added logic patterns with existing feature vectors, means for identifying similar logic patterns and notifying the user, and means for the user to search for specific logic patterns and display the search results. This enables efficient management of source code and design documents and allows similar patterns to be quickly identified and provided to the user, thereby significantly improving development efficiency.

[0088] "Source code" is digital data in text form used to describe the instructions or statements of a computer program.

[0089] A "design document" is a document that details the design specifications, structure, and operation of software or a system.

[0090] A "logic pattern" is an extraction of a specific structure or processing flow that is repeated in source code or algorithms.

[0091] A "feature vector" is vector-format data that represents the characteristics and attributes of each element as a number in data analysis and machine learning.

[0092] "Matching" refers to the process of comparing two or more pieces of data or information to find matches or similarities.

[0093] A "server" is a computer or software system that provides data and services to clients over a network.

[0094] "User" refers to the person or device that uses the system or software.

[0095] A "machine learning model" is an algorithm or mathematical model that analyzes and learns from large amounts of data to automatically perform predictions, classifications, and pattern recognition.

[0096] A "query" refers to an inquiry or request sent to a database or search system to retrieve information or data.

[0097] An "HTTP response" is a response message based on the HTTP protocol that is sent from a server to a client.

[0098] The purpose of this system is to effectively utilize existing logic patterns in order to improve the efficiency of software development. A specific embodiment of the system will be described below.

[0099] System configuration

[0100] This system consists of three elements: a server, a terminal, and a user.

[0101] The server has the following features:

[0102] 1. Ability to collect source code and design documentation.

[0103] 2. The ability to analyze collected data and extract logic patterns.

[0104] 3. A function to save the extracted logic patterns as feature vectors.

[0105] 4. Ability to match newly added logic patterns with existing ones.

[0106] 5. Ability to identify similar logic patterns and notify users.

[0107] 6. The ability to process user search queries and search for relevant logic patterns.

[0108] The terminal has the following features:

[0109] 1. Provides an interface for users to access the system.

[0110] 2. Send the user's search query to the server.

[0111] 3. Receive and display the response from the server.

[0112] The user has the following capabilities:

[0113] 1. Enter a search query through the interface provided by the system.

[0114] 2. Check notifications and search results from the server to obtain the necessary information.

[0115] Hardware and Software Used

[0116] Server: A high-performance computing device is required, for example, using a Linux server or cloud-based infrastructure (e.g., Amazon Web Services, Google Cloud Platform).

[0117] Parsing software: Use the Python ast module or the JavaParser library.

[0118] Database: To store feature vectors and pattern information, we use an SQL database (e.g., MySQL (registered trademark), PostgreSQL) or a NoSQL database (e.g., MongoDB).

[0119] Machine learning model: Use libraries such as scikit-learn or TENSORFLOW® to generate feature vectors for logic patterns.

[0120] Specific actions

[0121] Data collection:

[0122] The server accesses the repository based on a set schedule to collect source code and design documents. For example, at 10 PM, it retrieves the latest commits from the repository using the GitHub API and stores them in a database.

[0123] Data Analysis:

[0124] The server analyzes the collected source code using Python's ast module or Java's JavaParser library, identifying patterns such as function definitions, loop structures, and conditional branching, and stores them in a database as feature vectors.

[0125] Pattern matching:

[0126] The newly added source code patterns are compared with existing patterns in the database using cosine similarity, Jacquard coefficient, etc. to calculate the similarity. Patterns with high similarity are saved along with link information.

[0127] Results presentation and search:

[0128] The server presents the user with a list of similar logic patterns, and the user inputs a search query through the interface and receives a response from the server. The user can click on an item in the list to view specific code snippets or design documents.

[0129] Specific examples

[0130] Example prompt sentence:

[0131] "What similar patterns can you give me for the new login verification code for my project?"

[0132] "Find code examples of handling past database connection errors"

[0133] This system allows software developers to efficiently utilize past implementations, reducing search costs and enabling faster new development, which is expected to significantly improve development efficiency.

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

[0135] Step 1: Data collection

[0136] Server: Automatically collects source code and design documents on a regular basis. Based on a set schedule (e.g., every day at 10 p.m.), it accesses the GitHub API or internal repository to retrieve the latest changes. The input is the repository URL and access information, and the output is the retrieved data of the latest source code and design documents.

[0137] Specific operation: The server sends an HTTP request to the repository to obtain the latest commit information, downloads the changed files, and stores them in an internal database.

[0138] Step 2: Data analysis

[0139] Server: Analyzes the collected source code and design documents and extracts logic patterns. The collected data is analyzed using Python's ast module or Java's JavaParser library. The input is the acquired source code and design documents, and the output is the extracted logic patterns.

[0140] Specific operation: The server analyzes newly acquired Java files using JavaParser to extract function definitions and conditional branch structures. The extracted patterns are then converted into feature vectors and stored in a database.

[0141] Step 3: Pattern matching

[0142] Server: Compares the newly added logic pattern with the patterns in the existing database and calculates the similarity. The input is the feature vector of the newly added logic pattern, and the output is the similarity matching result.

[0143] Specific operation: The server compares the newly extracted feature vector with the feature vectors in the existing database using cosine similarity, calculates the similarity score, and generates a list of highly similar patterns, which are then stored in the database as link information.

[0144] Step 4: Presenting the results

[0145] Server: Notifies the user of a candidate list of similar logic patterns. The input is the result of similarity matching, and the output is the candidate list provided to the user.

[0146] Users can view the results list through a terminal interface and view specific code snippets and design documentation.

[0147] Specific operation: The server sends a list of patterns with high similarity scores to the terminal as an HTTP response. The user can click on an item in the list to view detailed information and use it in new developments.

[0148] Step 5: Search and suggest

[0149] User: Enters a query to search for a specific logic pattern into the terminal interface and sends it to the server. The input is the user's query, and the output is a search result list from the server.

[0150] Server: Based on the received query, it searches the database for relevant logic patterns and provides the results to the user in a list format. The input is the user's query, and the output is a list of search results.

[0151] Specific operation: The server searches the database based on the query and creates a list of related logic patterns. The results are sent to the user as an HTTP response. The user can then review the search results and use the selected code and design documents to develop new applications.

[0152] Thus, each step of the system provides a specific set of processes to improve efficiency in software development.

[0153] (Application example 1)

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

[0155] In factory automation systems, there is a need to efficiently optimize the control programs for various robots and reduce development costs. However, it is not easy to find effective logic patterns from past programs and design documents, which increases development time and the risk of errors. In addition, managing and optimizing newly added programs is difficult, so a method to improve overall work efficiency is needed.

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

[0157] In this invention, the server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying a user, and means for optimizing and proposing logic patterns to be applied to the factory automation system. This makes it possible to promote the reuse of effective programs from the past and improve the efficiency of developing new programs.

[0158] "Source code" is a human-readable form of text that describes the behavior of a program.

[0159] A "design document" is a document that describes in detail the structure, specifications, and functions of software or a system.

[0160] "Means of collection" refers to the functions and processes for collecting source code and design documents in a certain format or manner.

[0161] "Means of analysis" refers to methods and tools for analyzing collected source code and design documents to understand their meaning and structure.

[0162] A "logic pattern" is a recurring structure of reusable algorithms or processing flows within program code.

[0163] "Means for saving and comparing with newly added logic patterns" refers to a function that stores existing logic patterns in a database and compares them with past patterns when new code is added.

[0164] "Similar logic patterns" refer to structurally similar algorithms or processing flows found in past data for the program being analyzed.

[0165] "Means for notifying" refers to means for notifying the user of information or results, such as sending an alert or message.

[0166] A "factory automation system" is the entire control system for automating production and manufacturing processes within a factory, and is made up of robots and machinery.

[0167] "Optimization and suggestion means" is a function that improves the logic patterns applied to factory automation systems and suggests appropriate methods for efficient operation.

[0168] The present invention relates to a system for improving development efficiency by utilizing existing logic patterns in software development. The system of the present invention involves a server, a terminal, and a user.

[0169] 1. Data Collection

[0170] The server periodically collects all robot control programs and design documents in the factory. According to a set nightly schedule (e.g., 10 p.m.), the server accesses the repository and retrieves the latest source code and design documents. This ensures that the latest programs are always stored in the collection database.

[0171] 2. Data Analysis

[0172] The server analyzes the collected programs and design documents and extracts logic patterns such as function definitions, loop structures, and conditional branching within the programs. A proprietary code analysis module (e.g., CodeAnalyzer) is used for the analysis. As a specific example, it analyzes Java files and extracts "try-catch" blocks.

[0173] 3. Pattern Matching

[0174] The server stores the extracted past logic patterns in a database and compares them with newly added programs. When a logic pattern applied to a new logistics or manufacturing system is added, it compares it with existing patterns and calculates the similarity. It uses a unique matching module such as PatternMatcher.

[0175] 4. Presentation of results

[0176] Based on the analysis and matching results, the server notifies the user of detailed information about similar patterns. By checking the information presented through the user interface, the user can efficiently acquire the knowledge necessary for development. For example, it can present optimized past patterns for new robot movements.

[0177] 5. Search and Suggestions

[0178] When a user enters a query for a specific logic pattern into the interface, the server searches for related logic patterns in the database and provides the results. This allows users to efficiently proceed with new development while referring to past implementations. For example, users can search for "error handling logic" to obtain related code lists.

[0179] Hardware and software used

[0180] Server: Plays a central role in collecting, analyzing, storing, and collating control programs and design documents.

[0181] Storage Device: Used to store collected data.

[0182] User interface: A browser or dedicated app allows users to view results and enter queries.

[0183] Code Analysis Module (CodeAnalyzer): A proprietary tool for program analysis.

[0184] Pattern Matching Module (PatternMatcher): A tool for matching new and existing logic patterns.

[0185] Examples of specific examples and prompts

[0186] As a specific example of use, if an engineer wants to optimize new robot operations, the server will search for similar logic patterns from the past and notify them along with the related source code. The engineer can then use the presented patterns as a reference to efficiently create new operational programs.

[0187] Example prompt sentence:

[0188] You are developing a system to efficiently optimize factory robot control programs. You are designing software that extracts patterns from past code, calculates similarities, and applies them to new code. Create a code analysis module and a pattern matching module according to the following requirements:

[0189] In this way, the system helps users quickly and effectively develop and optimize control programs for factory robots.

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

[0191] Step 1: Data collection

[0192] The server periodically collects all robot control programs and design documents in the factory. At this time, the server accesses the repository according to a set schedule (for example, at 10 p.m.) to obtain the latest source code and design documents. The input is the contents of the repository, and the output is the collected source code and design documents.

[0193] Step 2: Save data

[0194] The server stores the collected source code and design documents in a database. Specifically, it stores the collected files on a storage device and indexes them in the database. The input is the collected data, and the output is the formatted data stored in the database.

[0195] Step 3: Data analysis

[0196] The server analyzes the stored data and extracts logic patterns within the program. Here, a code analysis module (CodeAnalyzer) is used to identify function definitions, loop structures, conditional branches, etc. The input is the stored source code, and the output is a list of extracted logic patterns.

[0197] Step 4: Save the logic pattern

[0198] The server stores the extracted logic patterns as feature vectors in a database, allowing for quick access for later pattern matching. The input is the extracted logic pattern, and the output is the feature vector stored in the database.

[0199] Step 5: Pattern matching

[0200] The server analyzes newly added program code and matches it with logic patterns in the existing database. A pattern matching module (PatternMatcher) is used to calculate the similarity. The input is the new source code, and the output is a list of similar patterns.

[0201] Step 6: Presenting the results

[0202] The server notifies the user based on the analysis results and pattern matching results. Specifically, it provides detailed information on similar past logic patterns through a user interface. The input is a list of similar patterns, and the output is information provided to the user via the user interface.

[0203] Step 7: User Search

[0204] When a user enters a logic pattern query into the interface, the server searches the database for related logic patterns. The search results are displayed to the user, and past implementation examples are provided as reference. The input is the user's query, and the output is a list of related logic patterns.

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

[0206] This system aims to utilize existing logic patterns in software development to improve development efficiency, while also recognizing user emotions and providing appropriate information. Below, we will explain the system's overview and specific processing flow.

[0207] System Overview

[0208] This system involves a server, a terminal, and a user. The server automatically collects, analyzes, and stores all source code and design documents within the company in a database, and recognizes user emotions using an emotion engine. The terminal provides an interface for users to access the system, receives user search queries and emotion data, and communicates with the server. Users operate the system by receiving notifications, checking result lists, and entering search queries.

[0209] Explaining program processing in natural language

[0210] 1. Data Collection

[0211] Server: Collects source code and design documents according to a regular schedule, accessing repositories and databases to identify, download, and store changed and newly added files.

[0212] Example: The server automatically accesses the repository at 10pm to get the latest state of the project.

[0213] 2. Data Analysis

[0214] Server: Analyzes the collected source code and design documents to extract logic patterns. Identifies patterns such as function definitions, loop structures, and conditional branching, organizes them into internal data structures, and creates templates.

[0215] Example: A server parses a Java file, extracts "try-catch" blocks, and saves them as feature vectors.

[0216] 3. Pattern Matching

[0217] Server: Matches newly added data with logic patterns in the existing database. Using machine learning algorithms, calculates the similarity between existing feature vectors and new feature vectors.

[0218] Example: The server analyzes the for loop of a newly added Python script and calculates the similarity by comparing it with past similar patterns.

[0219] 4. Presentation of results

[0220] Server: Identifies similar logic patterns and prepares the results in the form of a list. The notification includes links to relevant code snippets and design documents.

[0221] Users: Receive notifications, view the results list in the interface, and view relevant information to use in new developments.

[0222] Example: The server detects a similar pattern for the new login verification code for "Project A" and notifies the user, "Please refer to your past login verification codes."

[0223] 5. Search and Suggestions

[0224] User: When searching for a specific logic pattern, the user enters a query into the interface and sends it to the server.

[0225] Server: Receives the query, searches for relevant logic patterns in the database, and returns the results to the user in the form of a list.

[0226] User: Check the results and, if necessary, use the selected code and design documents to develop new ideas.

[0227] Example: A user searches for "database connection error handling," and the server returns a code list containing similar patterns from the past. The user can use this as a reference to create new error handling code.

[0228] 6. Emotion recognition

[0229] Server: Using the emotion engine, analyzes user input and usage to identify the user's emotions. Based on the identified emotions, the information and notification content is dynamically adjusted.

[0230] Example: If the server analyzes the user's input speed and frequency of error messages and determines that the user is stressed, it will provide more detailed guidance and support links.

[0231] This system allows developers to efficiently reuse past implementations, reducing search costs and providing appropriate information based on user sentiment, thereby improving the efficiency and quality of software development.

[0232] The processing flow will be explained below.

[0233] Step 1:

[0234] The server collects source code and design documents on a regular schedule, accesses a repository or database, identifies changed or newly added files, and downloads these files to local storage in text format.

[0235] Step 2:

[0236] The server analyzes the collected source code and design documents. It uses a syntax analysis engine to parse the source code, extract each code structure (e.g., function, loop, conditional branch), and organizes the analysis results into an internal data structure to identify logic patterns.

[0237] Step 3:

[0238] The server creates templates from the extracted logic patterns and generates feature vectors. The characteristics of each pattern are quantified, converted into vector format, and stored in a database for machine learning.

[0239] Step 4:

[0240] The server analyzes newly added source code and design documents, compares the extracted logic patterns with logic patterns in the existing database, and uses a machine learning algorithm to calculate the similarity between the existing feature vector and the new feature vector.

[0241] Step 5:

[0242] The server identifies similar logic patterns based on the similarity score, and if the similarity exceeds a threshold, identifies the pattern and prepares the results in a list format.

[0243] Step 6:

[0244] The server notifies the user of a list of identified similar logic patterns, including links to relevant code snippets and design documents, and provides this information to the user through a user interface.

[0245] Step 7:

[0246] Users receive a notification and can view the results list on the interface. They can click on the details of identified similar logic patterns to view related information and use it for new development.

[0247] Step 8:

[0248] When a user is searching for a particular logic pattern, they enter a query into the interface, which is sent to the server, which searches for relevant logic patterns in its database.

[0249] Step 9:

[0250] The server generates a list of search results and returns them to the user via a user interface. The user can then refer to the results to find the code snippets or design documents they need.

[0251] Step 10:

[0252] The server uses an emotion engine to analyze the user's input and usage status to identify the user's emotions. It analyzes data such as input speed and frequency of error messages to determine whether the user is feeling stressed.

[0253] Step 11:

[0254] The server dynamically adjusts the information and notifications it presents based on the user's emotions. For example, if the user is feeling stressed, it will provide more detailed guidance and support links.

[0255] Step 12:

[0256] Users receive information and support that responds to their emotions, which in turn allows them to carry out development work more efficiently.

[0257] This series of processes allows developers to efficiently reuse past implementations, reduce search costs, and provide appropriate information based on the user's emotions.

[0258] Example 2

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

[0260] In conventional software development, there is a lack of efficient means for reusing past source code and design documents, which tends to reduce development efficiency. Furthermore, there is no system that recognizes user emotions and provides appropriate information, making it difficult to reduce user stress. This invention aims to solve these problems.

[0261] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying the user, means for analyzing the user's input and usage status and identifying the user's emotions, and means for adjusting the notification content based on the identified emotions. This enables developers to efficiently reuse past implementations and provide appropriate information according to the user's emotions.

[0262] "Source code" is the textual description used to write a program.

[0263] A "design document" is a technical document that describes the structure and operation of software.

[0264] The "means of collection" is a mechanism for automatically acquiring and storing source code and design documents.

[0265] "Means of analysis" is the process for reading logic patterns from collected data.

[0266] "Logic patterns" refer to common logical structures or blocks of code used within a program.

[0267] "Means for saving" refers to a mechanism for saving the extracted logic patterns in storage such as a database.

[0268] "Matching" is the process of comparing the newly added logic pattern with the existing patterns.

[0269] "Means of notification" are functions or processes for notifying users of specific information.

[0270] The "means for identifying emotions" is a function that analyzes the user's input and usage status to determine the user's emotions.

[0271] The "means for adjusting notification content" is a mechanism for dynamically changing the information provided based on the user's emotions.

[0272] This system aims to utilize existing logic patterns in software development to improve development efficiency, while recognizing user emotions and providing appropriate information. The detailed configuration and specific processing flow of the system are explained below.

[0273] System configuration

[0274] This system involves a server, a terminal, and a user.

[0275] server

[0276] The server acts as a central point for collecting and analyzing source code and design documents. The server has the following functions:

[0277] Harvesting: Periodically retrieves source code and design documents from repositories and version control systems. Specifically, it uses the "git pull" command to pull in the latest changes and downloads changed and newly added files.

[0278] Analysis function: Analyzes the collected source code and design documents to extract logic patterns such as function definitions, loop structures, conditional branching, etc. Specifically, it uses the JavaParser library to analyze Java source code.

[0279] Pattern matching function: Compares extracted logic patterns with existing database contents. Calculates similarity using machine learning algorithms (e.g., k-nearest neighbor method).

[0280] Notification: Identifies similar logic patterns and notifies the user, with links to related code snippets and design documentation.

[0281] Emotion recognition: The emotion engine analyzes user input and usage to identify the user's emotions, and dynamically adjusts notification content based on the identified emotions.

[0282] Terminal

[0283] The terminal provides an interface for the user to access and operate the system.

[0284] Interface function: Provides a GUI (Graphical User Interface) for users to enter search queries and display results. Also receives notifications from the server and displays the results.

[0285] User

[0286] Users use the system to develop software.

[0287] Input function: A query can be entered to search for a specific logic pattern.

[0288] Viewing function: Receive notifications from the server, check the result list, and refer to related information as needed.

[0289] Specific examples

[0290] Data collection: The server runs a script every night at 10pm to retrieve the latest "user_authentication.java" file from the Git repository and save it to local storage.

[0291] Data analysis: The server analyzes "user_authentication.java" using the JavaParser library and extracts the pattern of the "try-catch" block.

[0292] Pattern matching: The server uses a machine learning algorithm (k-nearest neighbor method) to match the extracted "try-catch" block with existing patterns and calculate the similarity.

[0293] Result presentation: The server detects similar patterns in past login verification codes and notifies the user, "Please refer to the past login verification codes." The user then accesses detailed design documents through the interface.

[0294] Emotion recognition: If the server analyzes the user's input speed and frequency of error messages and determines that the user is stressed, it will provide more polite guidance or support links.

[0295] Example prompts for generative AI models

[0296] "Please explain in detail how you analyzed the collected source code."

[0297] "Please tell me some specific techniques for creating logic pattern templates."

[0298] "Give me an example of pattern matching using a machine learning algorithm."

[0299] "Please explain how the system recognizes user emotions and how to utilize them."

[0300] "Please tell me specifically how to present the search results in a list format."

[0301] This system allows developers to efficiently reuse past implementations, reducing search costs and providing appropriate information based on user sentiment, thereby improving the efficiency and quality of software development.

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

[0303] Step 1: Data collection

[0304] Input: The repository and version control system information to be collected.

[0305] Server: A script runs periodically (for example, every night at 10 PM) to access the repository and retrieve the latest source code and design documents. In particular, it downloads only changed or newly added files and stores them in a database.

[0306] Specific operation: The server updates the repository using the "git pull" command, retrieves the newly added "user_authentication.java" file, and saves it in local storage.

[0307] Output: The latest source code and design document data are stored in a database.

[0308] Step 2: Data analysis

[0309] Input: Collected source code and design documents.

[0310] Server: A parser is used to analyze the collected data. For Java files, the JavaParser library is used to extract logic patterns such as function definitions, loop structures, and conditional branching.

[0311] Specific behavior: The server parses the "user_authentication.java" file, extracts the "try-catch" block, and stores it in an internal data structure.

[0312] Output: Data of extracted logic patterns.

[0313] Step 3: Pattern matching

[0314] Input: Logic patterns extracted by analysis and logic patterns stored in an existing database.

[0315] Server: Matches newly extracted logic patterns with logic patterns in the existing database. Calculates the similarity of feature vectors using a machine learning algorithm (e.g., k-nearest neighbor method).

[0316] Specific operation: The server calculates the feature vector of the "try-catch" block and evaluates the similarity by comparing it with past similar patterns.

[0317] Output: A list of similar logic patterns.

[0318] Step 4: Presenting the results

[0319] Input: A list of similar patterns obtained by pattern matching.

[0320] Server: Identifies similar logic patterns and notifies the user, including links to relevant code snippets and design documentation.

[0321] Specific behavior: The server notifies the user, "Please refer to past login verification codes," and provides the user with a list of similar patterns and a link.

[0322] Output: Notification sent to the user.

[0323] Step 5: Search and suggest

[0324] Input: A query from the user.

[0325] User: Enters a query into the interface to search for a specific logic pattern and sends it to the server.

[0326] Server: Receives the query, searches for relevant logic patterns in the database, and returns the results to the user in the form of a list.

[0327] Specific behavior: The user searches for "database connection error handling," the server returns a list of code containing similar patterns, and the user reviews the list to create new error handling code.

[0328] Output: The list of search results sent to the user.

[0329] Step 6: Emotion Recognition

[0330] Input: User input and usage data.

[0331] Server: Uses an emotion engine to analyze the user's input speed and frequency of error messages to identify the user's emotions.

[0332] What it does: The server detects that the user is typing slowly or making frequent errors, determines that the user is stressed, and provides more detailed guidance and support links to the user.

[0333] Output: Notification content and supporting information tailored based on sentiment.

[0334] (Application example 2)

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

[0336] In conventional software development, it has been difficult to efficiently reuse past code and design patterns when designing new logic. Furthermore, there has been a lack of mechanisms for identifying factors that contribute to stress and confusion during development and providing appropriate information and support. This can have a negative impact on development efficiency and quality. The purpose of this invention is to solve these problems, improve development efficiency, and provide appropriate support that responds to user emotions.

[0337] 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 collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying the user, and means for recognizing the user's emotions and providing appropriate information. This enables efficient reuse of past logic patterns and makes it possible to provide appropriate support according to the user's emotions.

[0338] "Source code" refers to a string of characters and codes used to describe a computer program, and is usually written in accordance with a programming language.

[0339] A "design document" is a document that describes the structure, functions, interfaces, etc. of a program in software development, and is used as a guideline for development.

[0340] "Analysis" is the process of breaking down, extracting, and evaluating collected information and data to clarify specific patterns and meanings.

[0341] "Logic patterns" refer to logical structures and methods that repeatedly appear in source code and design documents, and are used to realize the functions and behavior of a program.

[0342] A "feature vector" is a collection of numbers that characterize logic patterns or other data and are used to represent that data in machine learning algorithms.

[0343] A "machine learning model" is a type of computer algorithm that makes predictions, classifications, and pattern detection based on data, learning from past experience data to make judgments about new data.

[0344] "Emotion recognition" is a technology that automatically determines and identifies emotions from user input data and behavior.

[0345] "Notification" is a means of transmitting information from the system to the user, and is used to inform the user of important information or results.

[0346] "Matching" refers to the process of comparing newly added data with existing data to check for matches and similarities.

[0347] "Search" is the act of locating required information from databases or documents based on specific conditions or queries.

[0348] "Results display" is the process of making answers to a user's search query and related information visible in the interface.

[0349] "User" refers to a person or entity that operates and uses a system or application.

[0350] This invention is a system and method applicable to a maintenance support application for factory robots. In this system, the factory robot performs self-diagnosis and sends the data to a server, which then compares it with past maintenance records and proposes the optimal correction method. It is also possible to recognize the user's emotions and provide appropriate support.

[0351] The server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying the user, and means for recognizing the user's emotions and providing appropriate information.

[0352] The server receives self-diagnosis data from the factory robot, analyzes it, and compares it with past maintenance records to propose optimal correction methods. It uses a machine learning model to generate and store feature vectors of logic patterns. It also recognizes emotions based on the user's input data and behavior, dynamically adjusts support content according to those emotions, and provides relevant information appropriately. This enables the efficient reuse of past logic patterns and provides appropriate support according to the user's emotions.

[0353] The terminal acts as a factory robot, performs self-diagnosis, transmits diagnostic data to the server, displays maintenance suggestions received from the server, and provides feedback to the user.

[0354] Users operate the system through an interface to search for specific logic patterns and display the results. The system analyzes input data and behavior to recognize the user's emotions and provides appropriate information. For example, if a user enters "I don't understand the maintenance procedures," the emotion recognition engine detects "stress" and provides additional support guidance.

[0355] Specific hardware and software components include factory robots, network connections, servers, Python programs, a virtual emotion recognition engine (EmotionEngine), and a REST API server.

[0356] (Example)

[0357] The factory robot performs self-diagnosis, detects error codes "E001" and "E002", and sends the data to the server.

[0358] The server suggests that "past correction method X is effective for error code E001," and notifies the robot and the user of the suggestion.

[0359] When a user types "I don't know how to do the maintenance," the emotion recognition engine detects "stress." Depending on the stress level, additional support guides are provided.

[0360] (Example of a prompt for a generative AI model)

[0361] "Analyze the self-diagnosis results and suggest the optimal maintenance method."

[0362] "Recognize emotions from user input and provide additional support as needed."

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

[0364] Step 1:

[0365] The terminal (factory robot) performs self-diagnosis. Specifically, it checks the current operating status and error log to see if there are any abnormalities. Sensor data and log files inside the robot are used as input. Diagnostic data including error codes and status information is generated as output.

[0366] Step 2:

[0367] The diagnostic data generated by the device is sent to the server. Specifically, the diagnostic data is encoded in JSON format and sent to the server's API endpoint using an HTTP request. The input is the diagnostic data generated by the device, and the output is the data sent to the server.

[0368] Step 3:

[0369] The server analyzes the received diagnostic data. Specifically, it examines each error code and compares it with a historical database. The input is the received diagnostic data. The output is a repair or maintenance suggestion corresponding to the error code.

[0370] Step 4:

[0371] The server uses a machine learning model to generate a feature vector. Specifically, it extracts logic patterns from the analysis results and saves them as a feature vector. The input is the analysis results obtained in step 3, and the output is the saved feature vector.

[0372] Step 5:

[0373] The server notifies the device of the identified correction methods and maintenance suggestions. Specifically, it encodes the suggestions in JSON format and sends them to the device as an HTTP response. The input is the generated feature vector and the maintenance suggestions, and the output is the notification data sent to the device.

[0374] Step 6:

[0375] The terminal displays the maintenance suggestions received from the server. The user performs the corresponding work based on the displayed information. The input is the suggestions received from the server, and the output is a notification to the user and the displayed maintenance information.

[0376] Step 7:

[0377] When a user provides input to the system, the server uses an emotion recognition engine to identify the user's emotion. Specifically, it analyzes the user's input data and operation log to recognize the user's emotional state. The input is the user's input data and operation log, and the output is the recognized emotional information.

[0378] Step 8:

[0379] The server dynamically adjusts appropriate information and support content based on the user's emotions. Specifically, it provides support guides and related information according to the recognized emotions. The input is the recognized emotion information and the search query, and the output is the adjusted support guides and related information.

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

[0381] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (registered trademark) (Internet search engine).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (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.

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

[0383] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0396] This system aims to improve development efficiency by utilizing existing logic patterns in software development. Below, we will explain the overview of the system and the specific processing flow.

[0397] System Overview

[0398] This system involves a server, a terminal, and a user. The server automatically collects, analyzes, and stores all source code and design documents in a database. The terminal provides an interface for users to access the system, receives user search queries, and communicates with the server.

[0399] Explaining program processing in natural language

[0400] 1. Data Collection

[0401] Server: Collects source code and design documents on a regular schedule, including accessing repositories and databases to detect recent changes.

[0402] Example: The server automatically accesses the repository at 10pm to get the latest state of the project.

[0403] 2. Data Analysis

[0404] Server: Parses the collected data and extracts logic patterns from each piece of code and design document. This includes identifying patterns such as function definitions, loop structures, and conditional branching.

[0405] Example: A server parses a Java file, extracts "try-catch" blocks, and saves them as feature vectors.

[0406] 3. Pattern Matching

[0407] Server: Matches newly added data with logic patterns in the existing database, and calculates and identifies similarities.

[0408] Example: The server analyzes the for loop of a newly added Python script and calculates the similarity by comparing it with past similar patterns.

[0409] 4. Presentation of results

[0410] Server: Notifies the user of similar logic patterns, including the ability to provide the user with detailed information about the identified patterns.

[0411] Users: Receive notifications, view a list of results in the interface, and click on the details of identified logic patterns to get the information they need for further development.

[0412] Example: The server detects a similar pattern for the new login verification code for "Project A" and notifies the user, "Please refer to your past login verification codes."

[0413] 5. Search and Suggestions

[0414] User: When searching for a specific logic pattern, the user enters a query into the interface and sends it to the server.

[0415] Server: Receives queries, searches for relevant logic patterns in the database, and sends the results to the user in the form of a list.

[0416] User: Check the results and, if necessary, use the selected code and design documents to develop new ideas.

[0417] Example: A user searches for "database connection error handling," and the server returns a code list containing similar patterns from the past. The user can use this as a reference to create new error handling code.

[0418] This system allows developers to effectively utilize past implementations, reducing search costs and enabling efficient new development.

[0419] The processing flow will be explained below.

[0420] Step 1:

[0421] The server collects source code and design documents on a regular schedule, accessing repositories and databases to identify changed and newly added files, and then downloads these files to local storage and saves them in text format.

[0422] Step 2:

[0423] The server analyzes the collected source code and design documents. First, it uses a syntax analysis engine to parse the source code and extract each code structure (e.g., function, loop, conditional branch). The analysis results are organized in an internal data structure and identified as logic patterns.

[0424] Step 3:

[0425] The server converts the extracted logic patterns into templates and generates feature vectors. This involves quantifying the characteristics of each pattern and converting them into vector format. The generated feature vectors are stored in a database for machine learning.

[0426] Step 4:

[0427] The server analyzes newly added source code and design documents, compares the extracted logic patterns with the existing database, and uses a machine learning algorithm to calculate the similarity between the existing feature vector and the new feature vector.

[0428] Step 5:

[0429] The server identifies similar logic patterns based on the similarity score, and if the similarity exceeds a threshold, identifies the pattern and prepares the results in a list format.

[0430] Step 6:

[0431] The server notifies the user of a list of identified similar logic patterns, including links to relevant code snippets and design documents, and provides this information to the user through a user interface.

[0432] Step 7:

[0433] Users receive a notification and view a list of results in the interface. They can click on the details of identified similar logic patterns to view related information. This information can then be used as a reference for new code or designs to further their development.

[0434] Step 8:

[0435] When a user searches for a particular logic pattern, they enter a query into the interface, which is sent to the server, which searches for relevant logic patterns in its database.

[0436] Step 9:

[0437] The server generates a list of search results and returns them to the user via a user interface. The user can then refer to the results to find the code snippets or design documents they need.

[0438] This series of processes allows developers to efficiently reuse past implementations and reduce search costs in new development.

[0439] Example 1

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

[0441] In software development, a system capable of efficiently managing and appropriately searching a large number of source codes and design documents is required to effectively utilize existing logic patterns and improve development efficiency. However, conventional systems collect, analyze, and search source codes and design documents separately, and lack a consistent workflow, making it difficult to efficiently support development work. Furthermore, there is a lack of a means to quickly identify the similarities between newly added logic patterns and existing patterns and notify users, which prevents developers from effectively utilizing past implementations.

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

[0443] In this invention, the server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns as feature vectors, means for comparing newly added logic patterns with existing feature vectors, means for identifying similar logic patterns and notifying the user, and means for the user to search for specific logic patterns and display the search results. This enables efficient management of source code and design documents and allows similar patterns to be quickly identified and provided to the user, thereby significantly improving development efficiency.

[0444] "Source code" is digital data in text form used to describe the instructions or statements of a computer program.

[0445] A "design document" is a document that details the design specifications, structure, and operation of software or a system.

[0446] A "logic pattern" is an extraction of a specific structure or processing flow that is repeated in source code or algorithms.

[0447] A "feature vector" is vector-format data that represents the characteristics and attributes of each element as a number in data analysis and machine learning.

[0448] "Matching" refers to the process of comparing two or more pieces of data or information to find matches or similarities.

[0449] A "server" is a computer or software system that provides data and services to clients over a network.

[0450] "User" refers to the person or device that uses the system or software.

[0451] A "machine learning model" is an algorithm or mathematical model that analyzes and learns from large amounts of data to automatically perform predictions, classifications, and pattern recognition.

[0452] A "query" refers to an inquiry or request sent to a database or search system to retrieve information or data.

[0453] An "HTTP response" is a response message based on the HTTP protocol that is sent from a server to a client.

[0454] The purpose of this system is to effectively utilize existing logic patterns in order to improve the efficiency of software development. A specific embodiment of the system will be described below.

[0455] System configuration

[0456] This system consists of three elements: a server, a terminal, and a user.

[0457] The server has the following features:

[0458] 1. Ability to collect source code and design documentation.

[0459] 2. The ability to analyze collected data and extract logic patterns.

[0460] 3. A function to save the extracted logic patterns as feature vectors.

[0461] 4. Ability to match newly added logic patterns with existing ones.

[0462] 5. Ability to identify similar logic patterns and notify users.

[0463] 6. The ability to process user search queries and search for relevant logic patterns.

[0464] The terminal has the following features:

[0465] 1. Provides an interface for users to access the system.

[0466] 2. Send the user's search query to the server.

[0467] 3. Receive and display the response from the server.

[0468] The user has the following capabilities:

[0469] 1. Enter a search query through the interface provided by the system.

[0470] 2. Check notifications and search results from the server to obtain the necessary information.

[0471] Hardware and Software Used

[0472] Server: A high-performance computing device is required, for example, using a Linux server or cloud-based infrastructure (e.g., Amazon Web Services, Google Cloud Platform).

[0473] Parsing software: Use the Python ast module or the JavaParser library.

[0474] Database: Use an SQL database (e.g., MySQL, PostgreSQL) or a NoSQL database (e.g., MongoDB) to store feature vectors and pattern information.

[0475] Machine learning models: Use libraries such as scikit-learn or TensorFlow to generate feature vectors for logic patterns.

[0476] Specific actions

[0477] Data collection:

[0478] The server accesses the repository based on a set schedule to collect source code and design documents. For example, at 10 PM, it retrieves the latest commits from the repository using the GitHub API and stores them in a database.

[0479] Data Analysis:

[0480] The server analyzes the collected source code using Python's ast module or Java's JavaParser library, identifying patterns such as function definitions, loop structures, and conditional branching, and stores them in a database as feature vectors.

[0481] Pattern matching:

[0482] The newly added source code patterns are compared with existing patterns in the database using cosine similarity, Jacquard coefficient, etc. to calculate the similarity. Patterns with high similarity are saved along with link information.

[0483] Results presentation and search:

[0484] The server presents the user with a list of similar logic patterns, and the user inputs a search query through the interface and receives a response from the server. The user can click on an item in the list to view specific code snippets or design documents.

[0485] Specific examples

[0486] Example prompt sentence:

[0487] "What similar patterns can you give me for the new login verification code for my project?"

[0488] "Find code examples of handling past database connection errors"

[0489] This system allows software developers to efficiently utilize past implementations, reducing search costs and enabling faster new development, which is expected to significantly improve development efficiency.

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

[0491] Step 1: Data collection

[0492] Server: Automatically collects source code and design documents on a regular basis. Based on a set schedule (e.g., every day at 10 p.m.), it accesses the GitHub API or internal repository to retrieve the latest changes. The input is the repository URL and access information, and the output is the retrieved data of the latest source code and design documents.

[0493] Specific operation: The server sends an HTTP request to the repository to obtain the latest commit information, downloads the changed files, and stores them in an internal database.

[0494] Step 2: Data analysis

[0495] Server: Analyzes the collected source code and design documents and extracts logic patterns. The collected data is analyzed using Python's ast module or Java's JavaParser library. The input is the acquired source code and design documents, and the output is the extracted logic patterns.

[0496] Specific operation: The server analyzes newly acquired Java files using JavaParser to extract function definitions and conditional branch structures. The extracted patterns are then converted into feature vectors and stored in a database.

[0497] Step 3: Pattern matching

[0498] Server: Compares the newly added logic pattern with the patterns in the existing database and calculates the similarity. The input is the feature vector of the newly added logic pattern, and the output is the similarity matching result.

[0499] Specific operation: The server compares the newly extracted feature vector with the feature vectors in the existing database using cosine similarity, calculates the similarity score, and generates a list of highly similar patterns, which are then stored in the database as link information.

[0500] Step 4: Presenting the results

[0501] Server: Notifies the user of a candidate list of similar logic patterns. The input is the result of similarity matching, and the output is the candidate list provided to the user.

[0502] Users can view the results list through a terminal interface and view specific code snippets and design documentation.

[0503] Specific operation: The server sends a list of patterns with high similarity scores to the terminal as an HTTP response. The user can click on an item in the list to view detailed information and use it in new developments.

[0504] Step 5: Search and suggest

[0505] User: Enters a query to search for a specific logic pattern into the terminal interface and sends it to the server. The input is the user's query, and the output is a search result list from the server.

[0506] Server: Based on the received query, it searches the database for relevant logic patterns and provides the results to the user in a list format. The input is the user's query, and the output is a list of search results.

[0507] Specific operation: The server searches the database based on the query and creates a list of related logic patterns. The results are sent to the user as an HTTP response. The user can then review the search results and use the selected code and design documents to develop new applications.

[0508] Thus, each step of the system provides a specific set of processes to improve efficiency in software development.

[0509] (Application example 1)

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

[0511] In factory automation systems, there is a need to efficiently optimize the control programs for various robots and reduce development costs. However, it is not easy to find effective logic patterns from past programs and design documents, which increases development time and the risk of errors. In addition, managing and optimizing newly added programs is difficult, so a method to improve overall work efficiency is needed.

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

[0513] In this invention, the server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying a user, and means for optimizing and proposing logic patterns to be applied to the factory automation system. This makes it possible to promote the reuse of effective programs from the past and improve the efficiency of developing new programs.

[0514] "Source code" is a human-readable form of text that describes the behavior of a program.

[0515] A "design document" is a document that describes in detail the structure, specifications, and functions of software or a system.

[0516] "Means of collection" refers to the functions and processes for collecting source code and design documents in a certain format or manner.

[0517] "Means of analysis" refers to methods and tools for analyzing collected source code and design documents to understand their meaning and structure.

[0518] A "logic pattern" is a recurring structure of reusable algorithms or processing flows within program code.

[0519] "Means for saving and comparing with newly added logic patterns" refers to a function that stores existing logic patterns in a database and compares them with past patterns when new code is added.

[0520] "Similar logic patterns" refer to structurally similar algorithms or processing flows found in past data for the program being analyzed.

[0521] "Means for notifying" refers to means for notifying the user of information or results, such as sending an alert or message.

[0522] A "factory automation system" is the entire control system for automating production and manufacturing processes within a factory, and is made up of robots and machinery.

[0523] "Optimization and suggestion means" is a function that improves the logic patterns applied to factory automation systems and suggests appropriate methods for efficient operation.

[0524] The present invention relates to a system for improving development efficiency by utilizing existing logic patterns in software development. The system of the present invention involves a server, a terminal, and a user.

[0525] 1. Data Collection

[0526] The server periodically collects all robot control programs and design documents in the factory. According to a set nightly schedule (e.g., 10 p.m.), the server accesses the repository and retrieves the latest source code and design documents. This ensures that the latest programs are always stored in the collection database.

[0527] 2. Data Analysis

[0528] The server analyzes the collected programs and design documents and extracts logic patterns such as function definitions, loop structures, and conditional branching within the programs. A proprietary code analysis module (e.g., CodeAnalyzer) is used for the analysis. As a specific example, it analyzes Java files and extracts "try-catch" blocks.

[0529] 3. Pattern Matching

[0530] The server stores the extracted past logic patterns in a database and compares them with newly added programs. When a logic pattern applied to a new logistics or manufacturing system is added, it compares it with existing patterns and calculates the similarity. It uses a unique matching module such as PatternMatcher.

[0531] 4. Presentation of results

[0532] Based on the analysis and matching results, the server notifies the user of detailed information about similar patterns. By checking the information presented through the user interface, the user can efficiently acquire the knowledge necessary for development. For example, it can present optimized past patterns for new robot movements.

[0533] 5. Search and Suggestions

[0534] When a user enters a query for a specific logic pattern into the interface, the server searches for related logic patterns in the database and provides the results. This allows users to efficiently proceed with new development while referring to past implementations. For example, users can search for "error handling logic" to obtain related code lists.

[0535] Hardware and software used

[0536] Server: Plays a central role in collecting, analyzing, storing, and collating control programs and design documents.

[0537] Storage Device: Used to store collected data.

[0538] User interface: A browser or dedicated app allows users to view results and enter queries.

[0539] Code Analysis Module (CodeAnalyzer): A proprietary tool for program analysis.

[0540] Pattern Matching Module (PatternMatcher): A tool for matching new and existing logic patterns.

[0541] Examples of specific examples and prompts

[0542] As a specific example of use, if an engineer wants to optimize new robot operations, the server will search for similar logic patterns from the past and notify them along with the related source code. The engineer can then use the presented patterns as a reference to efficiently create new operational programs.

[0543] Example prompt sentence:

[0544] You are developing a system to efficiently optimize factory robot control programs. You are designing software that extracts patterns from past code, calculates similarities, and applies them to new code. Create a code analysis module and a pattern matching module according to the following requirements:

[0545] In this way, the system helps users quickly and effectively develop and optimize control programs for factory robots.

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

[0547] Step 1: Data collection

[0548] The server periodically collects all robot control programs and design documents in the factory. At this time, the server accesses the repository according to a set schedule (for example, at 10 p.m.) to obtain the latest source code and design documents. The input is the contents of the repository, and the output is the collected source code and design documents.

[0549] Step 2: Save data

[0550] The server stores the collected source code and design documents in a database. Specifically, it stores the collected files on a storage device and indexes them in the database. The input is the collected data, and the output is the formatted data stored in the database.

[0551] Step 3: Data analysis

[0552] The server analyzes the stored data and extracts logic patterns within the program. Here, a code analysis module (CodeAnalyzer) is used to identify function definitions, loop structures, conditional branches, etc. The input is the stored source code, and the output is a list of extracted logic patterns.

[0553] Step 4: Save the logic pattern

[0554] The server stores the extracted logic patterns as feature vectors in a database, allowing for quick access for later pattern matching. The input is the extracted logic pattern, and the output is the feature vector stored in the database.

[0555] Step 5: Pattern matching

[0556] The server analyzes newly added program code and matches it with logic patterns in the existing database. A pattern matching module (PatternMatcher) is used to calculate the similarity. The input is the new source code, and the output is a list of similar patterns.

[0557] Step 6: Presenting the results

[0558] The server notifies the user based on the analysis results and pattern matching results. Specifically, it provides detailed information on similar past logic patterns through a user interface. The input is a list of similar patterns, and the output is information provided to the user via the user interface.

[0559] Step 7: User Search

[0560] When a user enters a logic pattern query into the interface, the server searches the database for related logic patterns. The search results are displayed to the user, and past implementation examples are provided as reference. The input is the user's query, and the output is a list of related logic patterns.

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

[0562] This system aims to utilize existing logic patterns in software development to improve development efficiency, while also recognizing user emotions and providing appropriate information. Below, we will explain the system's overview and specific processing flow.

[0563] System Overview

[0564] This system involves a server, a terminal, and a user. The server automatically collects, analyzes, and stores all source code and design documents within the company in a database, and recognizes user emotions using an emotion engine. The terminal provides an interface for users to access the system, receives user search queries and emotion data, and communicates with the server. Users operate the system by receiving notifications, checking result lists, and entering search queries.

[0565] Explaining program processing in natural language

[0566] 1. Data Collection

[0567] Server: Collects source code and design documents according to a regular schedule, accessing repositories and databases to identify, download, and store changed and newly added files.

[0568] Example: The server automatically accesses the repository at 10pm to get the latest state of the project.

[0569] 2. Data Analysis

[0570] Server: Analyzes the collected source code and design documents to extract logic patterns. Identifies patterns such as function definitions, loop structures, and conditional branching, organizes them into internal data structures, and creates templates.

[0571] Example: A server parses a Java file, extracts "try-catch" blocks, and saves them as feature vectors.

[0572] 3. Pattern Matching

[0573] Server: Matches newly added data with logic patterns in the existing database. Using machine learning algorithms, calculates the similarity between existing feature vectors and new feature vectors.

[0574] Example: The server analyzes the for loop of a newly added Python script and calculates the similarity by comparing it with past similar patterns.

[0575] 4. Presentation of results

[0576] Server: Identifies similar logic patterns and prepares the results in the form of a list. The notification includes links to relevant code snippets and design documents.

[0577] Users: Receive notifications, view the results list in the interface, and view relevant information to use in new developments.

[0578] Example: The server detects a similar pattern for the new login verification code for "Project A" and notifies the user, "Please refer to your past login verification codes."

[0579] 5. Search and Suggestions

[0580] User: When searching for a specific logic pattern, the user enters a query into the interface and sends it to the server.

[0581] Server: Receives the query, searches for relevant logic patterns in the database, and returns the results to the user in the form of a list.

[0582] User: Check the results and, if necessary, use the selected code and design documents to develop new ideas.

[0583] Example: A user searches for "database connection error handling," and the server returns a code list containing similar patterns from the past. The user can use this as a reference to create new error handling code.

[0584] 6. Emotion recognition

[0585] Server: Using the emotion engine, analyzes user input and usage to identify the user's emotions. Based on the identified emotions, the information and notification content is dynamically adjusted.

[0586] Example: If the server analyzes the user's input speed and frequency of error messages and determines that the user is stressed, it will provide more detailed guidance and support links.

[0587] This system allows developers to efficiently reuse past implementations, reducing search costs and providing appropriate information based on user sentiment, thereby improving the efficiency and quality of software development.

[0588] The processing flow will be explained below.

[0589] Step 1:

[0590] The server collects source code and design documents on a regular schedule, accesses a repository or database, identifies changed or newly added files, and downloads these files to local storage in text format.

[0591] Step 2:

[0592] The server analyzes the collected source code and design documents. It uses a syntax analysis engine to parse the source code, extract each code structure (e.g., function, loop, conditional branch), and organizes the analysis results into an internal data structure to identify logic patterns.

[0593] Step 3:

[0594] The server creates templates from the extracted logic patterns and generates feature vectors. The characteristics of each pattern are quantified, converted into vector format, and stored in a database for machine learning.

[0595] Step 4:

[0596] The server analyzes newly added source code and design documents, compares the extracted logic patterns with logic patterns in the existing database, and uses a machine learning algorithm to calculate the similarity between the existing feature vector and the new feature vector.

[0597] Step 5:

[0598] The server identifies similar logic patterns based on the similarity score, and if the similarity exceeds a threshold, identifies the pattern and prepares the results in a list format.

[0599] Step 6:

[0600] The server notifies the user of a list of identified similar logic patterns, including links to relevant code snippets and design documents, and provides this information to the user through a user interface.

[0601] Step 7:

[0602] Users receive a notification and can view the results list on the interface. They can click on the details of identified similar logic patterns to view related information and use it for new development.

[0603] Step 8:

[0604] When a user is searching for a particular logic pattern, they enter a query into the interface, which is sent to the server, which searches for relevant logic patterns in its database.

[0605] Step 9:

[0606] The server generates a list of search results and returns them to the user via a user interface. The user can then refer to the results to find the code snippets or design documents they need.

[0607] Step 10:

[0608] The server uses an emotion engine to analyze the user's input and usage status to identify the user's emotions. It analyzes data such as input speed and frequency of error messages to determine whether the user is feeling stressed.

[0609] Step 11:

[0610] The server dynamically adjusts the information and notifications it presents based on the user's emotions. For example, if the user is feeling stressed, it will provide more detailed guidance and support links.

[0611] Step 12:

[0612] Users receive information and support that responds to their emotions, which in turn allows them to carry out development work more efficiently.

[0613] This series of processes allows developers to efficiently reuse past implementations, reduce search costs, and provide appropriate information based on the user's emotions.

[0614] Example 2

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

[0616] In conventional software development, there is a lack of efficient means for reusing past source code and design documents, which tends to reduce development efficiency. Furthermore, there is no system that recognizes user emotions and provides appropriate information, making it difficult to reduce user stress. This invention aims to solve these problems.

[0617] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying the user, means for analyzing the user's input and usage status and identifying the user's emotions, and means for adjusting the notification content based on the identified emotions. This enables developers to efficiently reuse past implementations and provide appropriate information according to the user's emotions.

[0618] "Source code" is the textual description used to write a program.

[0619] A "design document" is a technical document that describes the structure and operation of software.

[0620] The "means of collection" is a mechanism for automatically acquiring and storing source code and design documents.

[0621] "Means of analysis" is the process for reading logic patterns from collected data.

[0622] "Logic patterns" refer to common logical structures or blocks of code used within a program.

[0623] "Means for saving" refers to a mechanism for saving the extracted logic patterns in storage such as a database.

[0624] "Matching" is the process of comparing the newly added logic pattern with the existing patterns.

[0625] "Means of notification" are functions or processes for notifying users of specific information.

[0626] The "means for identifying emotions" is a function that analyzes the user's input and usage status to determine the user's emotions.

[0627] The "means for adjusting notification content" is a mechanism for dynamically changing the information provided based on the user's emotions.

[0628] This system aims to utilize existing logic patterns in software development to improve development efficiency, while recognizing user emotions and providing appropriate information. The detailed configuration and specific processing flow of the system are explained below.

[0629] System configuration

[0630] This system involves a server, a terminal, and a user.

[0631] server

[0632] The server acts as a central point for collecting and analyzing source code and design documents. The server has the following functions:

[0633] Harvesting: Periodically retrieves source code and design documents from repositories and version control systems. Specifically, it uses the "git pull" command to pull in the latest changes and downloads changed and newly added files.

[0634] Analysis function: Analyzes the collected source code and design documents to extract logic patterns such as function definitions, loop structures, conditional branching, etc. Specifically, it uses the JavaParser library to analyze Java source code.

[0635] Pattern matching function: Compares extracted logic patterns with existing database contents. Calculates similarity using machine learning algorithms (e.g., k-nearest neighbor method).

[0636] Notification: Identifies similar logic patterns and notifies the user, with links to related code snippets and design documentation.

[0637] Emotion recognition: The emotion engine analyzes user input and usage to identify the user's emotions, and dynamically adjusts notification content based on the identified emotions.

[0638] Terminal

[0639] The terminal provides an interface for the user to access and operate the system.

[0640] Interface function: Provides a GUI (Graphical User Interface) for users to enter search queries and display results. Also receives notifications from the server and displays the results.

[0641] User

[0642] Users use the system to develop software.

[0643] Input function: A query can be entered to search for a specific logic pattern.

[0644] Viewing function: Receive notifications from the server, check the result list, and refer to related information as needed.

[0645] Specific examples

[0646] Data collection: The server runs a script every night at 10pm to retrieve the latest "user_authentication.java" file from the Git repository and save it to local storage.

[0647] Data analysis: The server analyzes "user_authentication.java" using the JavaParser library and extracts the pattern of the "try-catch" block.

[0648] Pattern matching: The server uses a machine learning algorithm (k-nearest neighbor method) to match the extracted "try-catch" block with existing patterns and calculate the similarity.

[0649] Result presentation: The server detects similar patterns in past login verification codes and notifies the user, "Please refer to the past login verification codes." The user then accesses detailed design documents through the interface.

[0650] Emotion recognition: If the server analyzes the user's input speed and frequency of error messages and determines that the user is stressed, it will provide more polite guidance or support links.

[0651] Example prompts for generative AI models

[0652] "Please explain in detail how you analyzed the collected source code."

[0653] "Please tell me some specific techniques for creating logic pattern templates."

[0654] "Give me an example of pattern matching using a machine learning algorithm."

[0655] "Please explain how the system recognizes user emotions and how to utilize them."

[0656] "Please tell me specifically how to present the search results in a list format."

[0657] This system allows developers to efficiently reuse past implementations, reducing search costs and providing appropriate information based on user sentiment, thereby improving the efficiency and quality of software development.

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

[0659] Step 1: Data collection

[0660] Input: The repository and version control system information to be collected.

[0661] Server: A script runs periodically (for example, every night at 10 PM) to access the repository and retrieve the latest source code and design documents. In particular, it downloads only changed or newly added files and stores them in a database.

[0662] Specific operation: The server updates the repository using the "git pull" command, retrieves the newly added "user_authentication.java" file, and saves it in local storage.

[0663] Output: The latest source code and design document data are stored in a database.

[0664] Step 2: Data analysis

[0665] Input: Collected source code and design documents.

[0666] Server: A parser is used to analyze the collected data. For Java files, the JavaParser library is used to extract logic patterns such as function definitions, loop structures, and conditional branching.

[0667] Specific behavior: The server parses the "user_authentication.java" file, extracts the "try-catch" block, and stores it in an internal data structure.

[0668] Output: Data of extracted logic patterns.

[0669] Step 3: Pattern matching

[0670] Input: Logic patterns extracted by analysis and logic patterns stored in an existing database.

[0671] Server: Matches newly extracted logic patterns with logic patterns in the existing database. Calculates the similarity of feature vectors using a machine learning algorithm (e.g., k-nearest neighbor method).

[0672] Specific operation: The server calculates the feature vector of the "try-catch" block and evaluates the similarity by comparing it with past similar patterns.

[0673] Output: A list of similar logic patterns.

[0674] Step 4: Presenting the results

[0675] Input: A list of similar patterns obtained by pattern matching.

[0676] Server: Identifies similar logic patterns and notifies the user, including links to relevant code snippets and design documentation.

[0677] Specific behavior: The server notifies the user, "Please refer to past login verification codes," and provides the user with a list of similar patterns and a link.

[0678] Output: Notification sent to the user.

[0679] Step 5: Search and suggest

[0680] Input: A query from the user.

[0681] User: Enters a query into the interface to search for a specific logic pattern and sends it to the server.

[0682] Server: Receives the query, searches for relevant logic patterns in the database, and returns the results to the user in the form of a list.

[0683] Specific behavior: The user searches for "database connection error handling," the server returns a list of code containing similar patterns, and the user reviews the list to create new error handling code.

[0684] Output: The list of search results sent to the user.

[0685] Step 6: Emotion Recognition

[0686] Input: User input and usage data.

[0687] Server: Uses an emotion engine to analyze the user's input speed and frequency of error messages to identify the user's emotions.

[0688] What it does: The server detects that the user is typing slowly or making frequent errors, determines that the user is stressed, and provides more detailed guidance and support links to the user.

[0689] Output: Notification content and supporting information tailored based on sentiment.

[0690] (Application example 2)

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

[0692] In conventional software development, it has been difficult to efficiently reuse past code and design patterns when designing new logic. Furthermore, there has been a lack of mechanisms for identifying factors that contribute to stress and confusion during development and providing appropriate information and support. This can have a negative impact on development efficiency and quality. The purpose of this invention is to solve these problems, improve development efficiency, and provide appropriate support that responds to user emotions.

[0693] 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 collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying the user, and means for recognizing the user's emotions and providing appropriate information. This enables efficient reuse of past logic patterns and makes it possible to provide appropriate support according to the user's emotions.

[0694] "Source code" refers to a string of characters and codes used to describe a computer program, and is usually written in accordance with a programming language.

[0695] A "design document" is a document that describes the structure, functions, interfaces, etc. of a program in software development, and is used as a guideline for development.

[0696] "Analysis" is the process of breaking down, extracting, and evaluating collected information and data to clarify specific patterns and meanings.

[0697] "Logic patterns" refer to logical structures and methods that repeatedly appear in source code and design documents, and are used to realize the functions and behavior of a program.

[0698] A "feature vector" is a collection of numbers that characterize logic patterns or other data and are used to represent that data in machine learning algorithms.

[0699] A "machine learning model" is a type of computer algorithm that makes predictions, classifications, and pattern detection based on data, learning from past experience data to make judgments about new data.

[0700] "Emotion recognition" is a technology that automatically determines and identifies emotions from user input data and behavior.

[0701] "Notification" is a means of transmitting information from the system to the user, and is used to inform the user of important information or results.

[0702] "Matching" refers to the process of comparing newly added data with existing data to check for matches and similarities.

[0703] "Search" is the act of locating required information from databases or documents based on specific conditions or queries.

[0704] "Results display" is the process of making answers to a user's search query and related information visible in the interface.

[0705] "User" refers to a person or entity that operates and uses a system or application.

[0706] This invention is a system and method applicable to a maintenance support application for factory robots. In this system, the factory robot performs self-diagnosis and sends the data to a server, which then compares it with past maintenance records and proposes the optimal correction method. It is also possible to recognize the user's emotions and provide appropriate support.

[0707] The server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying the user, and means for recognizing the user's emotions and providing appropriate information.

[0708] The server receives self-diagnosis data from the factory robot, analyzes it, and compares it with past maintenance records to propose optimal correction methods. It uses a machine learning model to generate and store feature vectors of logic patterns. It also recognizes emotions based on the user's input data and behavior, dynamically adjusts support content according to those emotions, and provides relevant information appropriately. This enables the efficient reuse of past logic patterns and provides appropriate support according to the user's emotions.

[0709] The terminal acts as a factory robot, performs self-diagnosis, transmits diagnostic data to the server, displays maintenance suggestions received from the server, and provides feedback to the user.

[0710] Users operate the system through an interface to search for specific logic patterns and display the results. The system analyzes input data and behavior to recognize the user's emotions and provides appropriate information. For example, if a user enters "I don't understand the maintenance procedures," the emotion recognition engine detects "stress" and provides additional support guidance.

[0711] Specific hardware and software components include factory robots, network connections, servers, Python programs, a virtual emotion recognition engine (EmotionEngine), and a REST API server.

[0712] (Example)

[0713] The factory robot performs self-diagnosis, detects error codes "E001" and "E002", and sends the data to the server.

[0714] The server suggests that "past correction method X is effective for error code E001," and notifies the robot and the user of the suggestion.

[0715] When a user types "I don't know how to do the maintenance," the emotion recognition engine detects "stress." Depending on the stress level, additional support guides are provided.

[0716] (Example of a prompt for a generative AI model)

[0717] "Analyze the self-diagnosis results and suggest the optimal maintenance method."

[0718] "Recognize emotions from user input and provide additional support as needed."

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

[0720] Step 1:

[0721] The terminal (factory robot) performs self-diagnosis. Specifically, it checks the current operating status and error log to see if there are any abnormalities. Sensor data and log files inside the robot are used as input. Diagnostic data including error codes and status information is generated as output.

[0722] Step 2:

[0723] The diagnostic data generated by the device is sent to the server. Specifically, the diagnostic data is encoded in JSON format and sent to the server's API endpoint using an HTTP request. The input is the diagnostic data generated by the device, and the output is the data sent to the server.

[0724] Step 3:

[0725] The server analyzes the received diagnostic data. Specifically, it examines each error code and compares it with a historical database. The input is the received diagnostic data. The output is a repair or maintenance suggestion corresponding to the error code.

[0726] Step 4:

[0727] The server uses a machine learning model to generate a feature vector. Specifically, it extracts logic patterns from the analysis results and saves them as a feature vector. The input is the analysis results obtained in step 3, and the output is the saved feature vector.

[0728] Step 5:

[0729] The server notifies the device of the identified correction methods and maintenance suggestions. Specifically, it encodes the suggestions in JSON format and sends them to the device as an HTTP response. The input is the generated feature vector and the maintenance suggestions, and the output is the notification data sent to the device.

[0730] Step 6:

[0731] The terminal displays the maintenance suggestions received from the server. The user performs the corresponding work based on the displayed information. The input is the suggestions received from the server, and the output is a notification to the user and the displayed maintenance information.

[0732] Step 7:

[0733] When a user provides input to the system, the server uses an emotion recognition engine to identify the user's emotion. Specifically, it analyzes the user's input data and operation log to recognize the user's emotional state. The input is the user's input data and operation log, and the output is the recognized emotional information.

[0734] Step 8:

[0735] The server dynamically adjusts appropriate information and support content based on the user's emotions. Specifically, it provides support guides and related information according to the recognized emotions. The input is the recognized emotion information and the search query, and the output is the adjusted support guides and related information.

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

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

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

[0739] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0752] This system aims to improve development efficiency by utilizing existing logic patterns in software development. Below, we will explain the overview of the system and the specific processing flow.

[0753] System Overview

[0754] This system involves a server, a terminal, and a user. The server automatically collects, analyzes, and stores all source code and design documents in a database. The terminal provides an interface for users to access the system, receives user search queries, and communicates with the server.

[0755] Explaining program processing in natural language

[0756] 1. Data Collection

[0757] Server: Collects source code and design documents on a regular schedule, including accessing repositories and databases to detect recent changes.

[0758] Example: The server automatically accesses the repository at 10pm to get the latest state of the project.

[0759] 2. Data Analysis

[0760] Server: Parses the collected data and extracts logic patterns from each piece of code and design document. This includes identifying patterns such as function definitions, loop structures, and conditional branching.

[0761] Example: A server parses a Java file, extracts "try-catch" blocks, and saves them as feature vectors.

[0762] 3. Pattern Matching

[0763] Server: Matches newly added data with logic patterns in the existing database, and calculates and identifies similarities.

[0764] Example: The server analyzes the for loop of a newly added Python script and calculates the similarity by comparing it with past similar patterns.

[0765] 4. Presentation of results

[0766] Server: Notifies the user of similar logic patterns, including the ability to provide the user with detailed information about the identified patterns.

[0767] Users: Receive notifications, view a list of results in the interface, and click on the details of identified logic patterns to get the information they need for further development.

[0768] Example: The server detects a similar pattern for the new login verification code for "Project A" and notifies the user, "Please refer to your past login verification codes."

[0769] 5. Search and Suggestions

[0770] User: When searching for a specific logic pattern, the user enters a query into the interface and sends it to the server.

[0771] Server: Receives queries, searches for relevant logic patterns in the database, and sends the results to the user in the form of a list.

[0772] User: Check the results and, if necessary, use the selected code and design documents to develop new ideas.

[0773] Example: A user searches for "database connection error handling," and the server returns a code list containing similar patterns from the past. The user can use this as a reference to create new error handling code.

[0774] This system allows developers to effectively utilize past implementations, reducing search costs and enabling efficient new development.

[0775] The processing flow will be explained below.

[0776] Step 1:

[0777] The server collects source code and design documents on a regular schedule, accessing repositories and databases to identify changed and newly added files, and then downloads these files to local storage and saves them in text format.

[0778] Step 2:

[0779] The server analyzes the collected source code and design documents. First, it uses a syntax analysis engine to parse the source code and extract each code structure (e.g., function, loop, conditional branch). The analysis results are organized in an internal data structure and identified as logic patterns.

[0780] Step 3:

[0781] The server converts the extracted logic patterns into templates and generates feature vectors. This involves quantifying the characteristics of each pattern and converting them into vector format. The generated feature vectors are stored in a database for machine learning.

[0782] Step 4:

[0783] The server analyzes newly added source code and design documents, compares the extracted logic patterns with the existing database, and uses a machine learning algorithm to calculate the similarity between the existing feature vector and the new feature vector.

[0784] Step 5:

[0785] The server identifies similar logic patterns based on the similarity score, and if the similarity exceeds a threshold, identifies the pattern and prepares the results in a list format.

[0786] Step 6:

[0787] The server notifies the user of a list of identified similar logic patterns, including links to relevant code snippets and design documents, and provides this information to the user through a user interface.

[0788] Step 7:

[0789] Users receive a notification and view a list of results in the interface. They can click on the details of identified similar logic patterns to view related information. This information can then be used as a reference for new code or designs to further their development.

[0790] Step 8:

[0791] When a user searches for a particular logic pattern, they enter a query into the interface, which is sent to the server, which searches for relevant logic patterns in its database.

[0792] Step 9:

[0793] The server generates a list of search results and returns them to the user via a user interface. The user can then refer to the results to find the code snippets or design documents they need.

[0794] This series of processes allows developers to efficiently reuse past implementations and reduce search costs in new development.

[0795] Example 1

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

[0797] In software development, a system capable of efficiently managing and appropriately searching a large number of source codes and design documents is required to effectively utilize existing logic patterns and improve development efficiency. However, conventional systems collect, analyze, and search source codes and design documents separately, and lack a consistent workflow, making it difficult to efficiently support development work. Furthermore, there is a lack of a means to quickly identify the similarities between newly added logic patterns and existing patterns and notify users, which prevents developers from effectively utilizing past implementations.

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

[0799] In this invention, the server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns as feature vectors, means for comparing newly added logic patterns with existing feature vectors, means for identifying similar logic patterns and notifying the user, and means for the user to search for specific logic patterns and display the search results. This enables efficient management of source code and design documents and allows similar patterns to be quickly identified and provided to the user, thereby significantly improving development efficiency.

[0800] "Source code" is digital data in text form used to describe the instructions or statements of a computer program.

[0801] A "design document" is a document that details the design specifications, structure, and operation of software or a system.

[0802] A "logic pattern" is an extraction of a specific structure or processing flow that is repeated in source code or algorithms.

[0803] A "feature vector" is vector-format data that represents the characteristics and attributes of each element as a number in data analysis and machine learning.

[0804] "Matching" refers to the process of comparing two or more pieces of data or information to find matches or similarities.

[0805] A "server" is a computer or software system that provides data and services to clients over a network.

[0806] "User" refers to the person or device that uses the system or software.

[0807] A "machine learning model" is an algorithm or mathematical model that analyzes and learns from large amounts of data to automatically perform predictions, classifications, and pattern recognition.

[0808] A "query" refers to an inquiry or request sent to a database or search system to retrieve information or data.

[0809] An "HTTP response" is a response message based on the HTTP protocol that is sent from a server to a client.

[0810] The purpose of this system is to effectively utilize existing logic patterns in order to improve the efficiency of software development. A specific embodiment of the system will be described below.

[0811] System configuration

[0812] This system consists of three elements: a server, a terminal, and a user.

[0813] The server has the following features:

[0814] 1. Ability to collect source code and design documentation.

[0815] 2. The ability to analyze collected data and extract logic patterns.

[0816] 3. A function to save the extracted logic patterns as feature vectors.

[0817] 4. Ability to match newly added logic patterns with existing ones.

[0818] 5. Ability to identify similar logic patterns and notify users.

[0819] 6. The ability to process user search queries and search for relevant logic patterns.

[0820] The terminal has the following features:

[0821] 1. Provides an interface for users to access the system.

[0822] 2. Send the user's search query to the server.

[0823] 3. Receive and display the response from the server.

[0824] The user has the following capabilities:

[0825] 1. Enter a search query through the interface provided by the system.

[0826] 2. Check notifications and search results from the server to obtain the necessary information.

[0827] Hardware and Software Used

[0828] Server: A high-performance computing device is required, for example, using a Linux server or cloud-based infrastructure (e.g., Amazon Web Services, Google Cloud Platform).

[0829] Parsing software: Use the Python ast module or the JavaParser library.

[0830] Database: Use an SQL database (e.g., MySQL, PostgreSQL) or a NoSQL database (e.g., MongoDB) to store feature vectors and pattern information.

[0831] Machine learning models: Use libraries such as scikit-learn or TensorFlow to generate feature vectors for logic patterns.

[0832] Specific actions

[0833] Data collection:

[0834] The server accesses the repository based on a set schedule to collect source code and design documents. For example, at 10 PM, it retrieves the latest commits from the repository using the GitHub API and stores them in a database.

[0835] Data Analysis:

[0836] The server analyzes the collected source code using Python's ast module or Java's JavaParser library, identifying patterns such as function definitions, loop structures, and conditional branching, and stores them in a database as feature vectors.

[0837] Pattern matching:

[0838] The newly added source code patterns are compared with existing patterns in the database using cosine similarity, Jacquard coefficient, etc. to calculate the similarity. Patterns with high similarity are saved along with link information.

[0839] Results presentation and search:

[0840] The server presents the user with a list of similar logic patterns, and the user inputs a search query through the interface and receives a response from the server. The user can click on an item in the list to view specific code snippets or design documents.

[0841] Specific examples

[0842] Example prompt sentence:

[0843] "What similar patterns can you give me for the new login verification code for my project?"

[0844] "Find code examples of handling past database connection errors"

[0845] This system allows software developers to efficiently utilize past implementations, reducing search costs and enabling faster new development, which is expected to significantly improve development efficiency.

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

[0847] Step 1: Data collection

[0848] Server: Automatically collects source code and design documents on a regular basis. Based on a set schedule (e.g., every day at 10 p.m.), it accesses the GitHub API or internal repository to retrieve the latest changes. The input is the repository URL and access information, and the output is the retrieved data of the latest source code and design documents.

[0849] Specific operation: The server sends an HTTP request to the repository to obtain the latest commit information, downloads the changed files, and stores them in an internal database.

[0850] Step 2: Data analysis

[0851] Server: Analyzes the collected source code and design documents and extracts logic patterns. The collected data is analyzed using Python's ast module or Java's JavaParser library. The input is the acquired source code and design documents, and the output is the extracted logic patterns.

[0852] Specific operation: The server analyzes newly acquired Java files using JavaParser to extract function definitions and conditional branch structures. The extracted patterns are then converted into feature vectors and stored in a database.

[0853] Step 3: Pattern matching

[0854] Server: Compares the newly added logic pattern with the patterns in the existing database and calculates the similarity. The input is the feature vector of the newly added logic pattern, and the output is the similarity matching result.

[0855] Specific operation: The server compares the newly extracted feature vector with the feature vectors in the existing database using cosine similarity, calculates the similarity score, and generates a list of highly similar patterns, which are then stored in the database as link information.

[0856] Step 4: Presenting the results

[0857] Server: Notifies the user of a candidate list of similar logic patterns. The input is the result of similarity matching, and the output is the candidate list provided to the user.

[0858] Users can view the results list through a terminal interface and view specific code snippets and design documentation.

[0859] Specific operation: The server sends a list of patterns with high similarity scores to the terminal as an HTTP response. The user can click on an item in the list to view detailed information and use it in new developments.

[0860] Step 5: Search and suggest

[0861] User: Enters a query to search for a specific logic pattern into the terminal interface and sends it to the server. The input is the user's query, and the output is a search result list from the server.

[0862] Server: Based on the received query, it searches the database for relevant logic patterns and provides the results to the user in a list format. The input is the user's query, and the output is a list of search results.

[0863] Specific operation: The server searches the database based on the query and creates a list of related logic patterns. The results are sent to the user as an HTTP response. The user can then review the search results and use the selected code and design documents to develop new applications.

[0864] Thus, each step of the system provides a specific set of processes to improve efficiency in software development.

[0865] (Application example 1)

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

[0867] In factory automation systems, there is a need to efficiently optimize the control programs for various robots and reduce development costs. However, it is not easy to find effective logic patterns from past programs and design documents, which increases development time and the risk of errors. In addition, managing and optimizing newly added programs is difficult, so a method to improve overall work efficiency is needed.

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

[0869] In this invention, the server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying a user, and means for optimizing and proposing logic patterns to be applied to the factory automation system. This makes it possible to promote the reuse of effective programs from the past and improve the efficiency of developing new programs.

[0870] "Source code" is a human-readable form of text that describes the behavior of a program.

[0871] A "design document" is a document that describes in detail the structure, specifications, and functions of software or a system.

[0872] "Means of collection" refers to the functions and processes for collecting source code and design documents in a certain format or manner.

[0873] "Means of analysis" refers to methods and tools for analyzing collected source code and design documents to understand their meaning and structure.

[0874] A "logic pattern" is a recurring structure of reusable algorithms or processing flows within program code.

[0875] "Means for saving and comparing with newly added logic patterns" refers to a function that stores existing logic patterns in a database and compares them with past patterns when new code is added.

[0876] "Similar logic patterns" refer to structurally similar algorithms or processing flows found in past data for the program being analyzed.

[0877] "Means for notifying" refers to means for notifying the user of information or results, such as sending an alert or message.

[0878] A "factory automation system" is the entire control system for automating production and manufacturing processes within a factory, and is made up of robots and machinery.

[0879] "Optimization and suggestion means" is a function that improves the logic patterns applied to factory automation systems and suggests appropriate methods for efficient operation.

[0880] The present invention relates to a system for improving development efficiency by utilizing existing logic patterns in software development. The system of the present invention involves a server, a terminal, and a user.

[0881] 1. Data Collection

[0882] The server periodically collects all robot control programs and design documents in the factory. According to a set nightly schedule (e.g., 10 p.m.), the server accesses the repository and retrieves the latest source code and design documents. This ensures that the latest programs are always stored in the collection database.

[0883] 2. Data Analysis

[0884] The server analyzes the collected programs and design documents and extracts logic patterns such as function definitions, loop structures, and conditional branching within the programs. A proprietary code analysis module (e.g., CodeAnalyzer) is used for the analysis. As a specific example, it analyzes Java files and extracts "try-catch" blocks.

[0885] 3. Pattern Matching

[0886] The server stores the extracted past logic patterns in a database and compares them with newly added programs. When a logic pattern applied to a new logistics or manufacturing system is added, it compares it with existing patterns and calculates the similarity. It uses a unique matching module such as PatternMatcher.

[0887] 4. Presentation of results

[0888] Based on the analysis and matching results, the server notifies the user of detailed information about similar patterns. By checking the information presented through the user interface, the user can efficiently acquire the knowledge necessary for development. For example, it can present optimized past patterns for new robot movements.

[0889] 5. Search and Suggestions

[0890] When a user enters a query for a specific logic pattern into the interface, the server searches for related logic patterns in the database and provides the results. This allows users to efficiently proceed with new development while referring to past implementations. For example, users can search for "error handling logic" to obtain related code lists.

[0891] Hardware and software used

[0892] Server: Plays a central role in collecting, analyzing, storing, and collating control programs and design documents.

[0893] Storage Device: Used to store collected data.

[0894] User interface: A browser or dedicated app allows users to view results and enter queries.

[0895] Code Analysis Module (CodeAnalyzer): A proprietary tool for program analysis.

[0896] Pattern Matching Module (PatternMatcher): A tool for matching new and existing logic patterns.

[0897] Examples of specific examples and prompts

[0898] As a specific example of use, if an engineer wants to optimize new robot operations, the server will search for similar logic patterns from the past and notify them along with the related source code. The engineer can then use the presented patterns as a reference to efficiently create new operational programs.

[0899] Example prompt sentence:

[0900] You are developing a system to efficiently optimize factory robot control programs. You are designing software that extracts patterns from past code, calculates similarities, and applies them to new code. Create a code analysis module and a pattern matching module according to the following requirements:

[0901] In this way, the system helps users quickly and effectively develop and optimize control programs for factory robots.

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

[0903] Step 1: Data collection

[0904] The server periodically collects all robot control programs and design documents in the factory. At this time, the server accesses the repository according to a set schedule (for example, at 10 p.m.) to obtain the latest source code and design documents. The input is the contents of the repository, and the output is the collected source code and design documents.

[0905] Step 2: Save data

[0906] The server stores the collected source code and design documents in a database. Specifically, it stores the collected files on a storage device and indexes them in the database. The input is the collected data, and the output is the formatted data stored in the database.

[0907] Step 3: Data analysis

[0908] The server analyzes the stored data and extracts logic patterns within the program. Here, a code analysis module (CodeAnalyzer) is used to identify function definitions, loop structures, conditional branches, etc. The input is the stored source code, and the output is a list of extracted logic patterns.

[0909] Step 4: Save the logic pattern

[0910] The server stores the extracted logic patterns as feature vectors in a database, allowing for quick access for later pattern matching. The input is the extracted logic pattern, and the output is the feature vector stored in the database.

[0911] Step 5: Pattern matching

[0912] The server analyzes newly added program code and matches it with logic patterns in the existing database. A pattern matching module (PatternMatcher) is used to calculate the similarity. The input is the new source code, and the output is a list of similar patterns.

[0913] Step 6: Presenting the results

[0914] The server notifies the user based on the analysis results and pattern matching results. Specifically, it provides detailed information on similar past logic patterns through a user interface. The input is a list of similar patterns, and the output is information provided to the user via the user interface.

[0915] Step 7: User Search

[0916] When a user enters a logic pattern query into the interface, the server searches the database for related logic patterns. The search results are displayed to the user, and past implementation examples are provided as reference. The input is the user's query, and the output is a list of related logic patterns.

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

[0918] This system aims to utilize existing logic patterns in software development to improve development efficiency, while also recognizing user emotions and providing appropriate information. Below, we will explain the system's overview and specific processing flow.

[0919] System Overview

[0920] This system involves a server, a terminal, and a user. The server automatically collects, analyzes, and stores all source code and design documents within the company in a database, and recognizes user emotions using an emotion engine. The terminal provides an interface for users to access the system, receives user search queries and emotion data, and communicates with the server. Users operate the system by receiving notifications, checking result lists, and entering search queries.

[0921] Explaining program processing in natural language

[0922] 1. Data Collection

[0923] Server: Collects source code and design documents according to a regular schedule, accessing repositories and databases to identify, download, and store changed and newly added files.

[0924] Example: The server automatically accesses the repository at 10pm to get the latest state of the project.

[0925] 2. Data Analysis

[0926] Server: Analyzes the collected source code and design documents to extract logic patterns. Identifies patterns such as function definitions, loop structures, and conditional branching, organizes them into internal data structures, and creates templates.

[0927] Example: A server parses a Java file, extracts "try-catch" blocks, and saves them as feature vectors.

[0928] 3. Pattern Matching

[0929] Server: Matches newly added data with logic patterns in the existing database. Using machine learning algorithms, calculates the similarity between existing feature vectors and new feature vectors.

[0930] Example: The server analyzes the for loop of a newly added Python script and calculates the similarity by comparing it with past similar patterns.

[0931] 4. Presentation of results

[0932] Server: Identifies similar logic patterns and prepares the results in the form of a list. The notification includes links to relevant code snippets and design documents.

[0933] Users: Receive notifications, view the results list in the interface, and view relevant information to use in new developments.

[0934] Example: The server detects a similar pattern for the new login verification code for "Project A" and notifies the user, "Please refer to your past login verification codes."

[0935] 5. Search and Suggestions

[0936] User: When searching for a specific logic pattern, the user enters a query into the interface and sends it to the server.

[0937] Server: Receives the query, searches for relevant logic patterns in the database, and returns the results to the user in the form of a list.

[0938] User: Check the results and, if necessary, use the selected code and design documents to develop new ideas.

[0939] Example: A user searches for "database connection error handling," and the server returns a code list containing similar patterns from the past. The user can use this as a reference to create new error handling code.

[0940] 6. Emotion recognition

[0941] Server: Using the emotion engine, analyzes user input and usage to identify the user's emotions. Based on the identified emotions, the information and notification content is dynamically adjusted.

[0942] Example: If the server analyzes the user's input speed and frequency of error messages and determines that the user is stressed, it will provide more detailed guidance and support links.

[0943] This system allows developers to efficiently reuse past implementations, reducing search costs and providing appropriate information based on user sentiment, thereby improving the efficiency and quality of software development.

[0944] The processing flow will be explained below.

[0945] Step 1:

[0946] The server collects source code and design documents on a regular schedule, accesses a repository or database, identifies changed or newly added files, and downloads these files to local storage in text format.

[0947] Step 2:

[0948] The server analyzes the collected source code and design documents. It uses a syntax analysis engine to parse the source code, extract each code structure (e.g., function, loop, conditional branch), and organizes the analysis results into an internal data structure to identify logic patterns.

[0949] Step 3:

[0950] The server creates templates from the extracted logic patterns and generates feature vectors. The characteristics of each pattern are quantified, converted into vector format, and stored in a database for machine learning.

[0951] Step 4:

[0952] The server analyzes newly added source code and design documents, compares the extracted logic patterns with logic patterns in the existing database, and uses a machine learning algorithm to calculate the similarity between the existing feature vector and the new feature vector.

[0953] Step 5:

[0954] The server identifies similar logic patterns based on the similarity score, and if the similarity exceeds a threshold, identifies the pattern and prepares the results in a list format.

[0955] Step 6:

[0956] The server notifies the user of a list of identified similar logic patterns, including links to relevant code snippets and design documents, and provides this information to the user through a user interface.

[0957] Step 7:

[0958] Users receive a notification and can view the results list on the interface. They can click on the details of identified similar logic patterns to view related information and use it for new development.

[0959] Step 8:

[0960] When a user is searching for a particular logic pattern, they enter a query into the interface, which is sent to the server, which searches for relevant logic patterns in its database.

[0961] Step 9:

[0962] The server generates a list of search results and returns them to the user via a user interface. The user can then refer to the results to find the code snippets or design documents they need.

[0963] Step 10:

[0964] The server uses an emotion engine to analyze the user's input and usage status to identify the user's emotions. It analyzes data such as input speed and frequency of error messages to determine whether the user is feeling stressed.

[0965] Step 11:

[0966] The server dynamically adjusts the information and notifications it presents based on the user's emotions. For example, if the user is feeling stressed, it will provide more detailed guidance and support links.

[0967] Step 12:

[0968] Users receive information and support that responds to their emotions, which in turn allows them to carry out development work more efficiently.

[0969] This series of processes allows developers to efficiently reuse past implementations, reduce search costs, and provide appropriate information based on the user's emotions.

[0970] Example 2

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

[0972] In conventional software development, there is a lack of efficient means for reusing past source code and design documents, which tends to reduce development efficiency. Furthermore, there is no system that recognizes user emotions and provides appropriate information, making it difficult to reduce user stress. This invention aims to solve these problems.

[0973] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying the user, means for analyzing the user's input and usage status and identifying the user's emotions, and means for adjusting the notification content based on the identified emotions. This enables developers to efficiently reuse past implementations and provide appropriate information according to the user's emotions.

[0974] "Source code" is the textual description used to write a program.

[0975] A "design document" is a technical document that describes the structure and operation of software.

[0976] The "means of collection" is a mechanism for automatically acquiring and storing source code and design documents.

[0977] "Means of analysis" is the process for reading logic patterns from collected data.

[0978] "Logic patterns" refer to common logical structures or blocks of code used within a program.

[0979] "Means for saving" refers to a mechanism for saving the extracted logic patterns in storage such as a database.

[0980] "Matching" is the process of comparing the newly added logic pattern with the existing patterns.

[0981] "Means of notification" are functions or processes for notifying users of specific information.

[0982] The "means for identifying emotions" is a function that analyzes the user's input and usage status to determine the user's emotions.

[0983] The "means for adjusting notification content" is a mechanism for dynamically changing the information provided based on the user's emotions.

[0984] This system aims to utilize existing logic patterns in software development to improve development efficiency, while recognizing user emotions and providing appropriate information. The detailed configuration and specific processing flow of the system are explained below.

[0985] System configuration

[0986] This system involves a server, a terminal, and a user.

[0987] server

[0988] The server acts as a central point for collecting and analyzing source code and design documents. The server has the following functions:

[0989] Harvesting: Periodically retrieves source code and design documents from repositories and version control systems. Specifically, it uses the "git pull" command to pull in the latest changes and downloads changed and newly added files.

[0990] Analysis function: Analyzes the collected source code and design documents to extract logic patterns such as function definitions, loop structures, conditional branching, etc. Specifically, it uses the JavaParser library to analyze Java source code.

[0991] Pattern matching function: Compares extracted logic patterns with existing database contents. Calculates similarity using machine learning algorithms (e.g., k-nearest neighbor method).

[0992] Notification: Identifies similar logic patterns and notifies the user, with links to related code snippets and design documentation.

[0993] Emotion recognition: The emotion engine analyzes user input and usage to identify the user's emotions, and dynamically adjusts notification content based on the identified emotions.

[0994] Terminal

[0995] The terminal provides an interface for the user to access and operate the system.

[0996] Interface function: Provides a GUI (Graphical User Interface) for users to enter search queries and display results. Also receives notifications from the server and displays the results.

[0997] User

[0998] Users use the system to develop software.

[0999] Input function: A query can be entered to search for a specific logic pattern.

[1000] Viewing function: Receive notifications from the server, check the result list, and refer to related information as needed.

[1001] Specific examples

[1002] Data collection: The server runs a script every night at 10pm to retrieve the latest "user_authentication.java" file from the Git repository and save it to local storage.

[1003] Data analysis: The server analyzes "user_authentication.java" using the JavaParser library and extracts the pattern of the "try-catch" block.

[1004] Pattern matching: The server uses a machine learning algorithm (k-nearest neighbor method) to match the extracted "try-catch" block with existing patterns and calculate the similarity.

[1005] Result presentation: The server detects similar patterns in past login verification codes and notifies the user, "Please refer to the past login verification codes." The user then accesses detailed design documents through the interface.

[1006] Emotion recognition: If the server analyzes the user's input speed and frequency of error messages and determines that the user is stressed, it will provide more polite guidance or support links.

[1007] Example prompts for generative AI models

[1008] "Please explain in detail how you analyzed the collected source code."

[1009] "Please tell me some specific techniques for creating logic pattern templates."

[1010] "Give me an example of pattern matching using a machine learning algorithm."

[1011] "Please explain how the system recognizes user emotions and how to utilize them."

[1012] "Please tell me specifically how to present the search results in a list format."

[1013] This system allows developers to efficiently reuse past implementations, reducing search costs and providing appropriate information based on user sentiment, thereby improving the efficiency and quality of software development.

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

[1015] Step 1: Data collection

[1016] Input: The repository and version control system information to be collected.

[1017] Server: A script runs periodically (for example, every night at 10 PM) to access the repository and retrieve the latest source code and design documents. In particular, it downloads only changed or newly added files and stores them in a database.

[1018] Specific operation: The server updates the repository using the "git pull" command, retrieves the newly added "user_authentication.java" file, and saves it in local storage.

[1019] Output: The latest source code and design document data are stored in a database.

[1020] Step 2: Data analysis

[1021] Input: Collected source code and design documents.

[1022] Server: A parser is used to analyze the collected data. For Java files, the JavaParser library is used to extract logic patterns such as function definitions, loop structures, and conditional branching.

[1023] Specific behavior: The server parses the "user_authentication.java" file, extracts the "try-catch" block, and stores it in an internal data structure.

[1024] Output: Data of extracted logic patterns.

[1025] Step 3: Pattern matching

[1026] Input: Logic patterns extracted by analysis and logic patterns stored in an existing database.

[1027] Server: Matches newly extracted logic patterns with logic patterns in the existing database. Calculates the similarity of feature vectors using a machine learning algorithm (e.g., k-nearest neighbor method).

[1028] Specific operation: The server calculates the feature vector of the "try-catch" block and evaluates the similarity by comparing it with past similar patterns.

[1029] Output: A list of similar logic patterns.

[1030] Step 4: Presenting the results

[1031] Input: A list of similar patterns obtained by pattern matching.

[1032] Server: Identifies similar logic patterns and notifies the user, including links to relevant code snippets and design documentation.

[1033] Specific behavior: The server notifies the user, "Please refer to past login verification codes," and provides the user with a list of similar patterns and a link.

[1034] Output: Notification sent to the user.

[1035] Step 5: Search and suggest

[1036] Input: A query from the user.

[1037] User: Enters a query into the interface to search for a specific logic pattern and sends it to the server.

[1038] Server: Receives the query, searches for relevant logic patterns in the database, and returns the results to the user in the form of a list.

[1039] Specific behavior: The user searches for "database connection error handling," the server returns a list of code containing similar patterns, and the user reviews the list to create new error handling code.

[1040] Output: The list of search results sent to the user.

[1041] Step 6: Emotion Recognition

[1042] Input: User input and usage data.

[1043] Server: Uses an emotion engine to analyze the user's input speed and frequency of error messages to identify the user's emotions.

[1044] What it does: The server detects that the user is typing slowly or making frequent errors, determines that the user is stressed, and provides more detailed guidance and support links to the user.

[1045] Output: Notification content and supporting information tailored based on sentiment.

[1046] (Application example 2)

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

[1048] In conventional software development, it has been difficult to efficiently reuse past code and design patterns when designing new logic. Furthermore, there has been a lack of mechanisms for identifying factors that contribute to stress and confusion during development and providing appropriate information and support. This can have a negative impact on development efficiency and quality. The purpose of this invention is to solve these problems, improve development efficiency, and provide appropriate support that responds to user emotions.

[1049] 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 collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying the user, and means for recognizing the user's emotions and providing appropriate information. This enables efficient reuse of past logic patterns and makes it possible to provide appropriate support according to the user's emotions.

[1050] "Source code" refers to a string of characters and codes used to describe a computer program, and is usually written in accordance with a programming language.

[1051] A "design document" is a document that describes the structure, functions, interfaces, etc. of a program in software development, and is used as a guideline for development.

[1052] "Analysis" is the process of breaking down, extracting, and evaluating collected information and data to clarify specific patterns and meanings.

[1053] "Logic patterns" refer to logical structures and methods that repeatedly appear in source code and design documents, and are used to realize the functions and behavior of a program.

[1054] A "feature vector" is a collection of numbers that characterize logic patterns or other data and are used to represent that data in machine learning algorithms.

[1055] A "machine learning model" is a type of computer algorithm that makes predictions, classifications, and pattern detection based on data, learning from past experience data to make judgments about new data.

[1056] "Emotion recognition" is a technology that automatically determines and identifies emotions from user input data and behavior.

[1057] "Notification" is a means of transmitting information from the system to the user, and is used to inform the user of important information or results.

[1058] "Matching" refers to the process of comparing newly added data with existing data to check for matches and similarities.

[1059] "Search" is the act of locating required information from databases or documents based on specific conditions or queries.

[1060] "Results display" is the process of making answers to a user's search query and related information visible in the interface.

[1061] "User" refers to a person or entity that operates and uses a system or application.

[1062] This invention is a system and method applicable to a maintenance support application for factory robots. In this system, the factory robot performs self-diagnosis and sends the data to a server, which then compares it with past maintenance records and proposes the optimal correction method. It is also possible to recognize the user's emotions and provide appropriate support.

[1063] The server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying the user, and means for recognizing the user's emotions and providing appropriate information.

[1064] The server receives self-diagnosis data from the factory robot, analyzes it, and compares it with past maintenance records to propose optimal correction methods. It uses a machine learning model to generate and store feature vectors of logic patterns. It also recognizes emotions based on the user's input data and behavior, dynamically adjusts support content according to those emotions, and provides relevant information appropriately. This enables the efficient reuse of past logic patterns and provides appropriate support according to the user's emotions.

[1065] The terminal acts as a factory robot, performs self-diagnosis, transmits diagnostic data to the server, displays maintenance suggestions received from the server, and provides feedback to the user.

[1066] Users operate the system through an interface to search for specific logic patterns and display the results. The system analyzes input data and behavior to recognize the user's emotions and provides appropriate information. For example, if a user enters "I don't understand the maintenance procedures," the emotion recognition engine detects "stress" and provides additional support guidance.

[1067] Specific hardware and software components include factory robots, network connections, servers, Python programs, a virtual emotion recognition engine (EmotionEngine), and a REST API server.

[1068] (Example)

[1069] The factory robot performs self-diagnosis, detects error codes "E001" and "E002", and sends the data to the server.

[1070] The server suggests that "past correction method X is effective for error code E001," and notifies the robot and the user of the suggestion.

[1071] When a user types "I don't know how to do the maintenance," the emotion recognition engine detects "stress." Depending on the stress level, additional support guides are provided.

[1072] (Example of a prompt for a generative AI model)

[1073] "Analyze the self-diagnosis results and suggest the optimal maintenance method."

[1074] "Recognize emotions from user input and provide additional support as needed."

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

[1076] Step 1:

[1077] The terminal (factory robot) performs self-diagnosis. Specifically, it checks the current operating status and error log to see if there are any abnormalities. Sensor data and log files inside the robot are used as input. Diagnostic data including error codes and status information is generated as output.

[1078] Step 2:

[1079] The diagnostic data generated by the device is sent to the server. Specifically, the diagnostic data is encoded in JSON format and sent to the server's API endpoint using an HTTP request. The input is the diagnostic data generated by the device, and the output is the data sent to the server.

[1080] Step 3:

[1081] The server analyzes the received diagnostic data. Specifically, it examines each error code and compares it with a historical database. The input is the received diagnostic data. The output is a repair or maintenance suggestion corresponding to the error code.

[1082] Step 4:

[1083] The server uses a machine learning model to generate a feature vector. Specifically, it extracts logic patterns from the analysis results and saves them as a feature vector. The input is the analysis results obtained in step 3, and the output is the saved feature vector.

[1084] Step 5:

[1085] The server notifies the device of the identified correction methods and maintenance suggestions. Specifically, it encodes the suggestions in JSON format and sends them to the device as an HTTP response. The input is the generated feature vector and the maintenance suggestions, and the output is the notification data sent to the device.

[1086] Step 6:

[1087] The terminal displays the maintenance suggestions received from the server. The user performs the corresponding work based on the displayed information. The input is the suggestions received from the server, and the output is a notification to the user and the displayed maintenance information.

[1088] Step 7:

[1089] When a user provides input to the system, the server uses an emotion recognition engine to identify the user's emotion. Specifically, it analyzes the user's input data and operation log to recognize the user's emotional state. The input is the user's input data and operation log, and the output is the recognized emotional information.

[1090] Step 8:

[1091] The server dynamically adjusts appropriate information and support content based on the user's emotions. Specifically, it provides support guides and related information according to the recognized emotions. The input is the recognized emotion information and the search query, and the output is the adjusted support guides and related information.

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

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

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

[1095] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1109] This system aims to improve development efficiency by utilizing existing logic patterns in software development. Below, we will explain the overview of the system and the specific processing flow.

[1110] System Overview

[1111] This system involves a server, a terminal, and a user. The server automatically collects, analyzes, and stores all source code and design documents in a database. The terminal provides an interface for users to access the system, receives user search queries, and communicates with the server.

[1112] Explaining program processing in natural language

[1113] 1. Data Collection

[1114] Server: Collects source code and design documents on a regular schedule, including accessing repositories and databases to detect recent changes.

[1115] Example: The server automatically accesses the repository at 10pm to get the latest state of the project.

[1116] 2. Data Analysis

[1117] Server: Parses the collected data and extracts logic patterns from each piece of code and design document. This includes identifying patterns such as function definitions, loop structures, and conditional branching.

[1118] Example: A server parses a Java file, extracts "try-catch" blocks, and saves them as feature vectors.

[1119] 3. Pattern Matching

[1120] Server: Matches newly added data with logic patterns in the existing database, and calculates and identifies similarities.

[1121] Example: The server analyzes the for loop of a newly added Python script and calculates the similarity by comparing it with past similar patterns.

[1122] 4. Presentation of results

[1123] Server: Notifies the user of similar logic patterns, including the ability to provide the user with detailed information about the identified patterns.

[1124] Users: Receive notifications, view a list of results in the interface, and click on the details of identified logic patterns to get the information they need for further development.

[1125] Example: The server detects a similar pattern for the new login verification code for "Project A" and notifies the user, "Please refer to your past login verification codes."

[1126] 5. Search and Suggestions

[1127] User: When searching for a specific logic pattern, the user enters a query into the interface and sends it to the server.

[1128] Server: Receives queries, searches for relevant logic patterns in the database, and sends the results to the user in the form of a list.

[1129] User: Check the results and, if necessary, use the selected code and design documents to develop new ideas.

[1130] Example: A user searches for "database connection error handling," and the server returns a code list containing similar patterns from the past. The user can use this as a reference to create new error handling code.

[1131] This system allows developers to effectively utilize past implementations, reducing search costs and enabling efficient new development.

[1132] The processing flow will be explained below.

[1133] Step 1:

[1134] The server collects source code and design documents on a regular schedule, accessing repositories and databases to identify changed and newly added files, and then downloads these files to local storage and saves them in text format.

[1135] Step 2:

[1136] The server analyzes the collected source code and design documents. First, it uses a syntax analysis engine to parse the source code and extract each code structure (e.g., function, loop, conditional branch). The analysis results are organized in an internal data structure and identified as logic patterns.

[1137] Step 3:

[1138] The server converts the extracted logic patterns into templates and generates feature vectors. This involves quantifying the characteristics of each pattern and converting them into vector format. The generated feature vectors are stored in a database for machine learning.

[1139] Step 4:

[1140] The server analyzes newly added source code and design documents, compares the extracted logic patterns with the existing database, and uses a machine learning algorithm to calculate the similarity between the existing feature vector and the new feature vector.

[1141] Step 5:

[1142] The server identifies similar logic patterns based on the similarity score, and if the similarity exceeds a threshold, identifies the pattern and prepares the results in a list format.

[1143] Step 6:

[1144] The server notifies the user of a list of identified similar logic patterns, including links to relevant code snippets and design documents, and provides this information to the user through a user interface.

[1145] Step 7:

[1146] Users receive a notification and view a list of results in the interface. They can click on the details of identified similar logic patterns to view related information. This information can then be used as a reference for new code or designs to further their development.

[1147] Step 8:

[1148] When a user searches for a particular logic pattern, they enter a query into the interface, which is sent to the server, which searches for relevant logic patterns in its database.

[1149] Step 9:

[1150] The server generates a list of search results and returns them to the user via a user interface. The user can then refer to the results to find the code snippets or design documents they need.

[1151] This series of processes allows developers to efficiently reuse past implementations and reduce search costs in new development.

[1152] Example 1

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

[1154] In software development, a system capable of efficiently managing and appropriately searching a large number of source codes and design documents is required to effectively utilize existing logic patterns and improve development efficiency. However, conventional systems collect, analyze, and search source codes and design documents separately, and lack a consistent workflow, making it difficult to efficiently support development work. Furthermore, there is a lack of a means to quickly identify the similarities between newly added logic patterns and existing patterns and notify users, which prevents developers from effectively utilizing past implementations.

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

[1156] In this invention, the server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns as feature vectors, means for comparing newly added logic patterns with existing feature vectors, means for identifying similar logic patterns and notifying the user, and means for the user to search for specific logic patterns and display the search results. This enables efficient management of source code and design documents and allows similar patterns to be quickly identified and provided to the user, thereby significantly improving development efficiency.

[1157] "Source code" is digital data in text form used to describe the instructions or statements of a computer program.

[1158] A "design document" is a document that details the design specifications, structure, and operation of software or a system.

[1159] A "logic pattern" is an extraction of a specific structure or processing flow that is repeated in source code or algorithms.

[1160] A "feature vector" is vector-format data that represents the characteristics and attributes of each element as a number in data analysis and machine learning.

[1161] "Matching" refers to the process of comparing two or more pieces of data or information to find matches or similarities.

[1162] A "server" is a computer or software system that provides data and services to clients over a network.

[1163] "User" refers to the person or device that uses the system or software.

[1164] A "machine learning model" is an algorithm or mathematical model that analyzes and learns from large amounts of data to automatically perform predictions, classifications, and pattern recognition.

[1165] A "query" refers to an inquiry or request sent to a database or search system to retrieve information or data.

[1166] An "HTTP response" is a response message based on the HTTP protocol that is sent from a server to a client.

[1167] The purpose of this system is to effectively utilize existing logic patterns in order to improve the efficiency of software development. A specific embodiment of the system will be described below.

[1168] System configuration

[1169] This system consists of three elements: a server, a terminal, and a user.

[1170] The server has the following features:

[1171] 1. Ability to collect source code and design documentation.

[1172] 2. The ability to analyze collected data and extract logic patterns.

[1173] 3. A function to save the extracted logic patterns as feature vectors.

[1174] 4. Ability to match newly added logic patterns with existing ones.

[1175] 5. Ability to identify similar logic patterns and notify users.

[1176] 6. The ability to process user search queries and search for relevant logic patterns.

[1177] The terminal has the following features:

[1178] 1. Provides an interface for users to access the system.

[1179] 2. Send the user's search query to the server.

[1180] 3. Receive and display the response from the server.

[1181] The user has the following capabilities:

[1182] 1. Enter a search query through the interface provided by the system.

[1183] 2. Check notifications and search results from the server to obtain the necessary information.

[1184] Hardware and Software Used

[1185] Server: A high-performance computing device is required, for example, using a Linux server or cloud-based infrastructure (e.g., Amazon Web Services, Google Cloud Platform).

[1186] Parsing software: Use the Python ast module or the JavaParser library.

[1187] Database: Use an SQL database (e.g., MySQL, PostgreSQL) or a NoSQL database (e.g., MongoDB) to store feature vectors and pattern information.

[1188] Machine learning models: Use libraries such as scikit-learn or TensorFlow to generate feature vectors for logic patterns.

[1189] Specific actions

[1190] Data collection:

[1191] The server accesses the repository based on a set schedule to collect source code and design documents. For example, at 10 PM, it retrieves the latest commits from the repository using the GitHub API and stores them in a database.

[1192] Data Analysis:

[1193] The server analyzes the collected source code using Python's ast module or Java's JavaParser library, identifying patterns such as function definitions, loop structures, and conditional branching, and stores them in a database as feature vectors.

[1194] Pattern matching:

[1195] The newly added source code patterns are compared with existing patterns in the database using cosine similarity, Jacquard coefficient, etc. to calculate the similarity. Patterns with high similarity are saved along with link information.

[1196] Results presentation and search:

[1197] The server presents the user with a list of similar logic patterns, and the user inputs a search query through the interface and receives a response from the server. The user can click on an item in the list to view specific code snippets or design documents.

[1198] Specific examples

[1199] Example prompt sentence:

[1200] "What similar patterns can you give me for the new login verification code for my project?"

[1201] "Find code examples of handling past database connection errors"

[1202] This system allows software developers to efficiently utilize past implementations, reducing search costs and enabling faster new development, which is expected to significantly improve development efficiency.

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

[1204] Step 1: Data collection

[1205] Server: Automatically collects source code and design documents on a regular basis. Based on a set schedule (e.g., every day at 10 p.m.), it accesses the GitHub API or internal repository to retrieve the latest changes. The input is the repository URL and access information, and the output is the retrieved data of the latest source code and design documents.

[1206] Specific operation: The server sends an HTTP request to the repository to obtain the latest commit information, downloads the changed files, and stores them in an internal database.

[1207] Step 2: Data analysis

[1208] Server: Analyzes the collected source code and design documents and extracts logic patterns. The collected data is analyzed using Python's ast module or Java's JavaParser library. The input is the acquired source code and design documents, and the output is the extracted logic patterns.

[1209] Specific operation: The server analyzes newly acquired Java files using JavaParser to extract function definitions and conditional branch structures. The extracted patterns are then converted into feature vectors and stored in a database.

[1210] Step 3: Pattern matching

[1211] Server: Compares the newly added logic pattern with the patterns in the existing database and calculates the similarity. The input is the feature vector of the newly added logic pattern, and the output is the similarity matching result.

[1212] Specific operation: The server compares the newly extracted feature vector with the feature vectors in the existing database using cosine similarity, calculates the similarity score, and generates a list of highly similar patterns, which are then stored in the database as link information.

[1213] Step 4: Presenting the results

[1214] Server: Notifies the user of a candidate list of similar logic patterns. The input is the result of similarity matching, and the output is the candidate list provided to the user.

[1215] Users can view the results list through a terminal interface and view specific code snippets and design documentation.

[1216] Specific operation: The server sends a list of patterns with high similarity scores to the terminal as an HTTP response. The user can click on an item in the list to view detailed information and use it in new developments.

[1217] Step 5: Search and suggest

[1218] User: Enters a query to search for a specific logic pattern into the terminal interface and sends it to the server. The input is the user's query, and the output is a search result list from the server.

[1219] Server: Based on the received query, it searches the database for relevant logic patterns and provides the results to the user in a list format. The input is the user's query, and the output is a list of search results.

[1220] Specific operation: The server searches the database based on the query and creates a list of related logic patterns. The results are sent to the user as an HTTP response. The user can then review the search results and use the selected code and design documents to develop new applications.

[1221] Thus, each step of the system provides a specific set of processes to improve efficiency in software development.

[1222] (Application example 1)

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

[1224] In factory automation systems, there is a need to efficiently optimize the control programs for various robots and reduce development costs. However, it is not easy to find effective logic patterns from past programs and design documents, which increases development time and the risk of errors. In addition, managing and optimizing newly added programs is difficult, so a method to improve overall work efficiency is needed.

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

[1226] In this invention, the server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying a user, and means for optimizing and proposing logic patterns to be applied to the factory automation system. This makes it possible to promote the reuse of effective programs from the past and improve the efficiency of developing new programs.

[1227] "Source code" is a human-readable form of text that describes the behavior of a program.

[1228] A "design document" is a document that describes in detail the structure, specifications, and functions of software or a system.

[1229] "Means of collection" refers to the functions and processes for collecting source code and design documents in a certain format or manner.

[1230] "Means of analysis" refers to methods and tools for analyzing collected source code and design documents to understand their meaning and structure.

[1231] A "logic pattern" is a recurring structure of reusable algorithms or processing flows within program code.

[1232] "Means for saving and comparing with newly added logic patterns" refers to a function that stores existing logic patterns in a database and compares them with past patterns when new code is added.

[1233] "Similar logic patterns" refer to structurally similar algorithms or processing flows found in past data for the program being analyzed.

[1234] "Means for notifying" refers to means for notifying the user of information or results, such as sending an alert or message.

[1235] A "factory automation system" is the entire control system for automating production and manufacturing processes within a factory, and is made up of robots and machinery.

[1236] "Optimization and suggestion means" is a function that improves the logic patterns applied to factory automation systems and suggests appropriate methods for efficient operation.

[1237] The present invention relates to a system for improving development efficiency by utilizing existing logic patterns in software development. The system of the present invention involves a server, a terminal, and a user.

[1238] 1. Data Collection

[1239] The server periodically collects all robot control programs and design documents in the factory. According to a set nightly schedule (e.g., 10 p.m.), the server accesses the repository and retrieves the latest source code and design documents. This ensures that the latest programs are always stored in the collection database.

[1240] 2. Data Analysis

[1241] The server analyzes the collected programs and design documents and extracts logic patterns such as function definitions, loop structures, and conditional branching within the programs. A proprietary code analysis module (e.g., CodeAnalyzer) is used for the analysis. As a specific example, it analyzes Java files and extracts "try-catch" blocks.

[1242] 3. Pattern Matching

[1243] The server stores the extracted past logic patterns in a database and compares them with newly added programs. When a logic pattern applied to a new logistics or manufacturing system is added, it compares it with existing patterns and calculates the similarity. It uses a unique matching module such as PatternMatcher.

[1244] 4. Presentation of results

[1245] Based on the analysis and matching results, the server notifies the user of detailed information about similar patterns. By checking the information presented through the user interface, the user can efficiently acquire the knowledge necessary for development. For example, it can present optimized past patterns for new robot movements.

[1246] 5. Search and Suggestions

[1247] When a user enters a query for a specific logic pattern into the interface, the server searches for related logic patterns in the database and provides the results. This allows users to efficiently proceed with new development while referring to past implementations. For example, users can search for "error handling logic" to obtain related code lists.

[1248] Hardware and software used

[1249] Server: Plays a central role in collecting, analyzing, storing, and collating control programs and design documents.

[1250] Storage Device: Used to store collected data.

[1251] User interface: A browser or dedicated app allows users to view results and enter queries.

[1252] Code Analysis Module (CodeAnalyzer): A proprietary tool for program analysis.

[1253] Pattern Matching Module (PatternMatcher): A tool for matching new and existing logic patterns.

[1254] Examples of specific examples and prompts

[1255] As a specific example of use, if an engineer wants to optimize new robot operations, the server will search for similar logic patterns from the past and notify them along with the related source code. The engineer can then use the presented patterns as a reference to efficiently create new operational programs.

[1256] Example prompt sentence:

[1257] You are developing a system to efficiently optimize factory robot control programs. You are designing software that extracts patterns from past code, calculates similarities, and applies them to new code. Create a code analysis module and a pattern matching module according to the following requirements:

[1258] In this way, the system helps users quickly and effectively develop and optimize control programs for factory robots.

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

[1260] Step 1: Data collection

[1261] The server periodically collects all robot control programs and design documents in the factory. At this time, the server accesses the repository according to a set schedule (for example, at 10 p.m.) to obtain the latest source code and design documents. The input is the contents of the repository, and the output is the collected source code and design documents.

[1262] Step 2: Save data

[1263] The server stores the collected source code and design documents in a database. Specifically, it stores the collected files on a storage device and indexes them in the database. The input is the collected data, and the output is the formatted data stored in the database.

[1264] Step 3: Data analysis

[1265] The server analyzes the stored data and extracts logic patterns within the program. Here, a code analysis module (CodeAnalyzer) is used to identify function definitions, loop structures, conditional branches, etc. The input is the stored source code, and the output is a list of extracted logic patterns.

[1266] Step 4: Save the logic pattern

[1267] The server stores the extracted logic patterns as feature vectors in a database, allowing for quick access for later pattern matching. The input is the extracted logic pattern, and the output is the feature vector stored in the database.

[1268] Step 5: Pattern matching

[1269] The server analyzes newly added program code and matches it with logic patterns in the existing database. A pattern matching module (PatternMatcher) is used to calculate the similarity. The input is the new source code, and the output is a list of similar patterns.

[1270] Step 6: Presenting the results

[1271] The server notifies the user based on the analysis results and pattern matching results. Specifically, it provides detailed information on similar past logic patterns through a user interface. The input is a list of similar patterns, and the output is information provided to the user via the user interface.

[1272] Step 7: User Search

[1273] When a user enters a logic pattern query into the interface, the server searches the database for related logic patterns. The search results are displayed to the user, and past implementation examples are provided as reference. The input is the user's query, and the output is a list of related logic patterns.

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

[1275] This system aims to utilize existing logic patterns in software development to improve development efficiency, while also recognizing user emotions and providing appropriate information. Below, we will explain the system's overview and specific processing flow.

[1276] System Overview

[1277] This system involves a server, a terminal, and a user. The server automatically collects, analyzes, and stores all source code and design documents within the company in a database, and recognizes user emotions using an emotion engine. The terminal provides an interface for users to access the system, receives user search queries and emotion data, and communicates with the server. Users operate the system by receiving notifications, checking result lists, and entering search queries.

[1278] Explaining program processing in natural language

[1279] 1. Data Collection

[1280] Server: Collects source code and design documents according to a regular schedule, accessing repositories and databases to identify, download, and store changed and newly added files.

[1281] Example: The server automatically accesses the repository at 10pm to get the latest state of the project.

[1282] 2. Data Analysis

[1283] Server: Analyzes the collected source code and design documents to extract logic patterns. Identifies patterns such as function definitions, loop structures, and conditional branching, organizes them into internal data structures, and creates templates.

[1284] Example: A server parses a Java file, extracts "try-catch" blocks, and saves them as feature vectors.

[1285] 3. Pattern Matching

[1286] Server: Matches newly added data with logic patterns in the existing database. Using machine learning algorithms, calculates the similarity between existing feature vectors and new feature vectors.

[1287] Example: The server analyzes the for loop of a newly added Python script and calculates the similarity by comparing it with past similar patterns.

[1288] 4. Presentation of results

[1289] Server: Identifies similar logic patterns and prepares the results in the form of a list. The notification includes links to relevant code snippets and design documents.

[1290] Users: Receive notifications, view the results list in the interface, and view relevant information to use in new developments.

[1291] Example: The server detects a similar pattern for the new login verification code for "Project A" and notifies the user, "Please refer to your past login verification codes."

[1292] 5. Search and Suggestions

[1293] User: When searching for a specific logic pattern, the user enters a query into the interface and sends it to the server.

[1294] Server: Receives the query, searches for relevant logic patterns in the database, and returns the results to the user in the form of a list.

[1295] User: Check the results and, if necessary, use the selected code and design documents to develop new ideas.

[1296] Example: A user searches for "database connection error handling," and the server returns a code list containing similar patterns from the past. The user can use this as a reference to create new error handling code.

[1297] 6. Emotion recognition

[1298] Server: Using the emotion engine, analyzes user input and usage to identify the user's emotions. Based on the identified emotions, the information and notification content is dynamically adjusted.

[1299] Example: If the server analyzes the user's input speed and frequency of error messages and determines that the user is stressed, it will provide more detailed guidance and support links.

[1300] This system allows developers to efficiently reuse past implementations, reducing search costs and providing appropriate information based on user sentiment, thereby improving the efficiency and quality of software development.

[1301] The processing flow will be explained below.

[1302] Step 1:

[1303] The server collects source code and design documents on a regular schedule, accesses a repository or database, identifies changed or newly added files, and downloads these files to local storage in text format.

[1304] Step 2:

[1305] The server analyzes the collected source code and design documents. It uses a syntax analysis engine to parse the source code, extract each code structure (e.g., function, loop, conditional branch), and organizes the analysis results into an internal data structure to identify logic patterns.

[1306] Step 3:

[1307] The server creates templates from the extracted logic patterns and generates feature vectors. The characteristics of each pattern are quantified, converted into vector format, and stored in a database for machine learning.

[1308] Step 4:

[1309] The server analyzes newly added source code and design documents, compares the extracted logic patterns with logic patterns in the existing database, and uses a machine learning algorithm to calculate the similarity between the existing feature vector and the new feature vector.

[1310] Step 5:

[1311] The server identifies similar logic patterns based on the similarity score, and if the similarity exceeds a threshold, identifies the pattern and prepares the results in a list format.

[1312] Step 6:

[1313] The server notifies the user of a list of identified similar logic patterns, including links to relevant code snippets and design documents, and provides this information to the user through a user interface.

[1314] Step 7:

[1315] Users receive a notification and can view the results list on the interface. They can click on the details of identified similar logic patterns to view related information and use it for new development.

[1316] Step 8:

[1317] When a user is searching for a particular logic pattern, they enter a query into the interface, which is sent to the server, which searches for relevant logic patterns in its database.

[1318] Step 9:

[1319] The server generates a list of search results and returns them to the user via a user interface. The user can then refer to the results to find the code snippets or design documents they need.

[1320] Step 10:

[1321] The server uses an emotion engine to analyze the user's input and usage status to identify the user's emotions. It analyzes data such as input speed and frequency of error messages to determine whether the user is feeling stressed.

[1322] Step 11:

[1323] The server dynamically adjusts the information and notifications it presents based on the user's emotions. For example, if the user is feeling stressed, it will provide more detailed guidance and support links.

[1324] Step 12:

[1325] Users receive information and support that responds to their emotions, which in turn allows them to carry out development work more efficiently.

[1326] This series of processes allows developers to efficiently reuse past implementations, reduce search costs, and provide appropriate information based on the user's emotions.

[1327] Example 2

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

[1329] In conventional software development, there is a lack of efficient means for reusing past source code and design documents, which tends to reduce development efficiency. Furthermore, there is no system that recognizes user emotions and provides appropriate information, making it difficult to reduce user stress. This invention aims to solve these problems.

[1330] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying the user, means for analyzing the user's input and usage status and identifying the user's emotions, and means for adjusting the notification content based on the identified emotions. This enables developers to efficiently reuse past implementations and provide appropriate information according to the user's emotions.

[1331] "Source code" is the textual description used to write a program.

[1332] A "design document" is a technical document that describes the structure and operation of software.

[1333] The "means of collection" is a mechanism for automatically acquiring and storing source code and design documents.

[1334] "Means of analysis" is the process for reading logic patterns from collected data.

[1335] "Logic patterns" refer to common logical structures or blocks of code used within a program.

[1336] "Means for saving" refers to a mechanism for saving the extracted logic patterns in storage such as a database.

[1337] "Matching" is the process of comparing the newly added logic pattern with the existing patterns.

[1338] "Means of notification" are functions or processes for notifying users of specific information.

[1339] The "means for identifying emotions" is a function that analyzes the user's input and usage status to determine the user's emotions.

[1340] The "means for adjusting notification content" is a mechanism for dynamically changing the information provided based on the user's emotions.

[1341] This system aims to utilize existing logic patterns in software development to improve development efficiency, while recognizing user emotions and providing appropriate information. The detailed configuration and specific processing flow of the system are explained below.

[1342] System configuration

[1343] This system involves a server, a terminal, and a user.

[1344] server

[1345] The server acts as a central point for collecting and analyzing source code and design documents. The server has the following functions:

[1346] Harvesting: Periodically retrieves source code and design documents from repositories and version control systems. Specifically, it uses the "git pull" command to pull in the latest changes and downloads changed and newly added files.

[1347] Analysis function: Analyzes the collected source code and design documents to extract logic patterns such as function definitions, loop structures, conditional branching, etc. Specifically, it uses the JavaParser library to analyze Java source code.

[1348] Pattern matching function: Compares extracted logic patterns with existing database contents. Calculates similarity using machine learning algorithms (e.g., k-nearest neighbor method).

[1349] Notification: Identifies similar logic patterns and notifies the user, with links to related code snippets and design documentation.

[1350] Emotion recognition: The emotion engine analyzes user input and usage to identify the user's emotions, and dynamically adjusts notification content based on the identified emotions.

[1351] Terminal

[1352] The terminal provides an interface for the user to access and operate the system.

[1353] Interface function: Provides a GUI (Graphical User Interface) for users to enter search queries and display results. Also receives notifications from the server and displays the results.

[1354] User

[1355] Users use the system to develop software.

[1356] Input function: A query can be entered to search for a specific logic pattern.

[1357] Viewing function: Receive notifications from the server, check the result list, and refer to related information as needed.

[1358] Specific examples

[1359] Data collection: The server runs a script every night at 10pm to retrieve the latest "user_authentication.java" file from the Git repository and save it to local storage.

[1360] Data analysis: The server analyzes "user_authentication.java" using the JavaParser library and extracts the pattern of the "try-catch" block.

[1361] Pattern matching: The server uses a machine learning algorithm (k-nearest neighbor method) to match the extracted "try-catch" block with existing patterns and calculate the similarity.

[1362] Result presentation: The server detects similar patterns in past login verification codes and notifies the user, "Please refer to the past login verification codes." The user then accesses detailed design documents through the interface.

[1363] Emotion recognition: If the server analyzes the user's input speed and frequency of error messages and determines that the user is stressed, it will provide more polite guidance or support links.

[1364] Example prompts for generative AI models

[1365] "Please explain in detail how you analyzed the collected source code."

[1366] "Please tell me some specific techniques for creating logic pattern templates."

[1367] "Give me an example of pattern matching using a machine learning algorithm."

[1368] "Please explain how the system recognizes user emotions and how to utilize them."

[1369] "Please tell me specifically how to present the search results in a list format."

[1370] This system allows developers to efficiently reuse past implementations, reducing search costs and providing appropriate information based on user sentiment, thereby improving the efficiency and quality of software development.

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

[1372] Step 1: Data collection

[1373] Input: The repository and version control system information to be collected.

[1374] Server: A script runs periodically (for example, every night at 10 PM) to access the repository and retrieve the latest source code and design documents. In particular, it downloads only changed or newly added files and stores them in a database.

[1375] Specific operation: The server updates the repository using the "git pull" command, retrieves the newly added "user_authentication.java" file, and saves it in local storage.

[1376] Output: The latest source code and design document data are stored in a database.

[1377] Step 2: Data analysis

[1378] Input: Collected source code and design documents.

[1379] Server: A parser is used to analyze the collected data. For Java files, the JavaParser library is used to extract logic patterns such as function definitions, loop structures, and conditional branching.

[1380] Specific behavior: The server parses the "user_authentication.java" file, extracts the "try-catch" block, and stores it in an internal data structure.

[1381] Output: Data of extracted logic patterns.

[1382] Step 3: Pattern matching

[1383] Input: Logic patterns extracted by analysis and logic patterns stored in an existing database.

[1384] Server: Matches newly extracted logic patterns with logic patterns in the existing database. Calculates the similarity of feature vectors using a machine learning algorithm (e.g., k-nearest neighbor method).

[1385] Specific operation: The server calculates the feature vector of the "try-catch" block and evaluates the similarity by comparing it with past similar patterns.

[1386] Output: A list of similar logic patterns.

[1387] Step 4: Presenting the results

[1388] Input: A list of similar patterns obtained by pattern matching.

[1389] Server: Identifies similar logic patterns and notifies the user, including links to relevant code snippets and design documentation.

[1390] Specific behavior: The server notifies the user, "Please refer to past login verification codes," and provides the user with a list of similar patterns and a link.

[1391] Output: Notification sent to the user.

[1392] Step 5: Search and suggest

[1393] Input: A query from the user.

[1394] User: Enters a query into the interface to search for a specific logic pattern and sends it to the server.

[1395] Server: Receives the query, searches for relevant logic patterns in the database, and returns the results to the user in the form of a list.

[1396] Specific behavior: The user searches for "database connection error handling," the server returns a list of code containing similar patterns, and the user reviews the list to create new error handling code.

[1397] Output: The list of search results sent to the user.

[1398] Step 6: Emotion Recognition

[1399] Input: User input and usage data.

[1400] Server: Uses an emotion engine to analyze the user's input speed and frequency of error messages to identify the user's emotions.

[1401] What it does: The server detects that the user is typing slowly or making frequent errors, determines that the user is stressed, and provides more detailed guidance and support links to the user.

[1402] Output: Notification content and supporting information tailored based on sentiment.

[1403] (Application example 2)

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

[1405] In conventional software development, it has been difficult to efficiently reuse past code and design patterns when designing new logic. Furthermore, there has been a lack of mechanisms for identifying factors that contribute to stress and confusion during development and providing appropriate information and support. This can have a negative impact on development efficiency and quality. The purpose of this invention is to solve these problems, improve development efficiency, and provide appropriate support that responds to user emotions.

[1406] 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 collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying the user, and means for recognizing the user's emotions and providing appropriate information. This enables efficient reuse of past logic patterns and makes it possible to provide appropriate support according to the user's emotions.

[1407] "Source code" refers to a string of characters and codes used to describe a computer program, and is usually written in accordance with a programming language.

[1408] A "design document" is a document that describes the structure, functions, interfaces, etc. of a program in software development, and is used as a guideline for development.

[1409] "Analysis" is the process of breaking down, extracting, and evaluating collected information and data to clarify specific patterns and meanings.

[1410] "Logic patterns" refer to logical structures and methods that repeatedly appear in source code and design documents, and are used to realize the functions and behavior of a program.

[1411] A "feature vector" is a collection of numbers that characterize logic patterns or other data and are used to represent that data in machine learning algorithms.

[1412] A "machine learning model" is a type of computer algorithm that makes predictions, classifications, and pattern detection based on data, learning from past experience data to make judgments about new data.

[1413] "Emotion recognition" is a technology that automatically determines and identifies emotions from user input data and behavior.

[1414] "Notification" is a means of transmitting information from the system to the user, and is used to inform the user of important information or results.

[1415] "Matching" refers to the process of comparing newly added data with existing data to check for matches and similarities.

[1416] "Search" is the act of locating required information from databases or documents based on specific conditions or queries.

[1417] "Results display" is the process of making answers to a user's search query and related information visible in the interface.

[1418] "User" refers to a person or entity that operates and uses a system or application.

[1419] This invention is a system and method applicable to a maintenance support application for factory robots. In this system, the factory robot performs self-diagnosis and sends the data to a server, which then compares it with past maintenance records and proposes the optimal correction method. It is also possible to recognize the user's emotions and provide appropriate support.

[1420] The server includes means for collecting source code and design documents, means for analyzing the collected source code and design documents and extracting logic patterns, means for saving the extracted logic patterns and comparing them with newly added logic patterns, means for identifying similar logic patterns and notifying the user, and means for recognizing the user's emotions and providing appropriate information.

[1421] The server receives self-diagnosis data from the factory robot, analyzes it, and compares it with past maintenance records to propose optimal correction methods. It uses a machine learning model to generate and store feature vectors of logic patterns. It also recognizes emotions based on the user's input data and behavior, dynamically adjusts support content according to those emotions, and provides relevant information appropriately. This enables the efficient reuse of past logic patterns and provides appropriate support according to the user's emotions.

[1422] The terminal acts as a factory robot, performs self-diagnosis, transmits diagnostic data to the server, displays maintenance suggestions received from the server, and provides feedback to the user.

[1423] Users operate the system through an interface to search for specific logic patterns and display the results. The system analyzes input data and behavior to recognize the user's emotions and provides appropriate information. For example, if a user enters "I don't understand the maintenance procedures," the emotion recognition engine detects "stress" and provides additional support guidance.

[1424] Specific hardware and software components include factory robots, network connections, servers, Python programs, a virtual emotion recognition engine (EmotionEngine), and a REST API server.

[1425] (Example)

[1426] The factory robot performs self-diagnosis, detects error codes "E001" and "E002", and sends the data to the server.

[1427] The server suggests that "past correction method X is effective for error code E001," and notifies the robot and the user of the suggestion.

[1428] When a user types "I don't know how to do the maintenance," the emotion recognition engine detects "stress." Depending on the stress level, additional support guides are provided.

[1429] (Example of a prompt for a generative AI model)

[1430] "Analyze the self-diagnosis results and suggest the optimal maintenance method."

[1431] "Recognize emotions from user input and provide additional support as needed."

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

[1433] Step 1:

[1434] The terminal (factory robot) performs self-diagnosis. Specifically, it checks the current operating status and error log to see if there are any abnormalities. Sensor data and log files inside the robot are used as input. Diagnostic data including error codes and status information is generated as output.

[1435] Step 2:

[1436] The diagnostic data generated by the device is sent to the server. Specifically, the diagnostic data is encoded in JSON format and sent to the server's API endpoint using an HTTP request. The input is the diagnostic data generated by the device, and the output is the data sent to the server.

[1437] Step 3:

[1438] The server analyzes the received diagnostic data. Specifically, it examines each error code and compares it with a historical database. The input is the received diagnostic data. The output is a repair or maintenance suggestion corresponding to the error code.

[1439] Step 4:

[1440] The server uses a machine learning model to generate a feature vector. Specifically, it extracts logic patterns from the analysis results and saves them as a feature vector. The input is the analysis results obtained in step 3, and the output is the saved feature vector.

[1441] Step 5:

[1442] The server notifies the device of the identified correction methods and maintenance suggestions. Specifically, it encodes the suggestions in JSON format and sends them to the device as an HTTP response. The input is the generated feature vector and the maintenance suggestions, and the output is the notification data sent to the device.

[1443] Step 6:

[1444] The terminal displays the maintenance suggestions received from the server. The user performs the corresponding work based on the displayed information. The input is the suggestions received from the server, and the output is a notification to the user and the displayed maintenance information.

[1445] Step 7:

[1446] When a user provides input to the system, the server uses an emotion recognition engine to identify the user's emotion. Specifically, it analyzes the user's input data and operation log to recognize the user's emotional state. The input is the user's input data and operation log, and the output is the recognized emotional information.

[1447] Step 8:

[1448] The server dynamically adjusts appropriate information and support content based on the user's emotions. Specifically, it provides support guides and related information according to the recognized emotions. The input is the recognized emotion information and the search query, and the output is the adjusted support guides and related information.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[1470] The following is further disclosed regarding the above embodiment.

[1471] (Claim 1)

[1472] a means for collecting source code and design documentation;

[1473] A means for analyzing the collected source code and design documents and extracting logic patterns;

[1474] A means for saving the extracted logic patterns and comparing them with newly added logic patterns;

[1475] A means for identifying similar logic patterns and notifying a user;

[1476] A system including:

[1477] (Claim 2)

[1478] 10. The system of claim 1, further comprising: means for generating and storing feature vectors of logic patterns using a machine learning model.

[1479] (Claim 3)

[1480] 10. The system of claim 1, further comprising means for a user to search for a particular logic pattern and display the results.

[1481] "Example 1"

[1482] (Claim 1)

[1483] a means for collecting source code and design documentation;

[1484] A means for analyzing the collected source code and design documents and extracting logic patterns;

[1485] A means for saving the extracted logic pattern as a feature vector;

[1486] A means for matching newly added logic patterns with existing feature vectors;

[1487] A means for identifying similar logic patterns and notifying a user;

[1488] a means for a user to search for a particular logic pattern and display search results;

[1489] A system including:

[1490] (Claim 2)

[1491] 10. The system of claim 1, further comprising: means for generating and storing feature vectors of logic patterns using a machine learning model.

[1492] (Claim 3)

[1493] 10. The system of claim 1, further comprising means for receiving a user query and providing search results to the user in the form of a list.

[1494] "Application Example 1"

[1495] (Claim 1)

[1496] a means for collecting source code and design documentation;

[1497] A means for analyzing the collected source code and design documents and extracting logic patterns;

[1498] A means for saving the extracted logic patterns and comparing them with newly added logic patterns;

[1499] A means for identifying similar logic patterns and notifying a user;

[1500] A means for optimizing and proposing logic patterns to be applied to a factory automation system;

[1501] A system including:

[1502] (Claim 2)

[1503] 10. The system of claim 1, further comprising: means for generating and storing feature vectors of logic patterns using a machine learning model.

[1504] (Claim 3)

[1505] 10. The system of claim 1, further comprising means for a user to search for a particular logic pattern and display the results.

[1506] "Example 2: Combining Emotion Engines"

[1507] (Claim 1)

[1508] a means for collecting source code and design documentation;

[1509] A means for analyzing the collected source code and design documents and extracting logic patterns;

[1510] A means for saving the extracted logic patterns and comparing them with newly added logic patterns;

[1511] A means for identifying similar logic patterns and notifying a user;

[1512] A means for analyzing user input and usage to identify user emotions;

[1513] means for tailoring notification content based on the identified emotion;

[1514] A system including:

[1515] (Claim 2)

[1516] 10. The system of claim 1, further comprising: means for generating and storing feature vectors of logic patterns using a machine learning model.

[1517] (Claim 3)

[1518] 10. The system of claim 1, further comprising means for a user to search for a particular logic pattern and display the results.

[1519] "Application example 2 when combining emotion engines"

[1520] (Claim 1)

[1521] a means for collecting source code and design documentation;

[1522] A means for analyzing the collected source code and design documents and extracting logic patterns;

[1523] A means for saving the extracted logic patterns and comparing them with newly added logic patterns;

[1524] A means for identifying similar logic patterns and notifying a user;

[1525] A means for recognizing the user's emotions and providing appropriate information;

[1526] A system including:

[1527] (Claim 2)

[1528] 10. The system of claim 1, further comprising: means for generating and storing feature vectors of logic patterns using a machine learning model.

[1529] (Claim 3)

[1530] 10. The system of claim 1, further comprising means for allowing a user to search for specific logic patterns and display results, and means for dynamically adjusting support content based on emotion. [Explanation of symbols]

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

Claims

1. a means for collecting source code and design documentation; A means for analyzing the collected source code and design documents and extracting logic patterns; A means for saving the extracted logic patterns and comparing them with newly added logic patterns; A means for identifying similar logic patterns and notifying a user; A system including:

2. The system of claim 1 , further comprising means for generating and storing feature vectors of logic patterns using a machine learning model.

3. 10. The system of claim 1, further comprising means for allowing a user to search for a particular logic pattern and display the results.

Images