system

Abstract

The system according to this embodiment aims to streamline the software development process and automatically detect and improve unnecessary processing and inefficient parts. [Solution] The system according to the embodiment comprises a static analysis unit, a test generation unit, a documentation generation unit, a vulnerability detection unit, and a UI testing unit. The static analysis unit performs static analysis of the source code. The test generation unit automatically generates test programs based on the unnecessary processing and inefficient parts detected by the static analysis unit. The documentation generation unit automatically generates relationship diagrams and transition diagrams based on the test programs generated by the test generation unit. The vulnerability detection unit detects vulnerabilities based on the documents generated by the documentation generation unit and proposes countermeasures. The UI testing unit automates user interface testing based on vulnerabilities detected by the vulnerability detection unit.

Description

Technical Field

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

Background Art

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

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] In the conventional technology, in the software development process, wasteful processing and inefficient parts have not been sufficiently detected, and appropriate countermeasures have not been automatically provided, leaving room for improvement.

[0005] The system according to the embodiment aims to improve the efficiency of the software development process and automatically detect and improve wasteful processing and inefficient parts.

Means for Solving the Problems

[0006] The system according to this embodiment comprises a static analysis unit, a test generation unit, a documentation generation unit, a vulnerability detection unit, and a UI testing unit. The static analysis unit performs static analysis of the source code. The test generation unit automatically generates test programs based on the unnecessary processing and inefficient parts detected by the static analysis unit. The documentation generation unit automatically generates relationship diagrams and transition diagrams based on the test programs generated by the test generation unit. The vulnerability detection unit detects vulnerabilities based on the documents generated by the documentation generation unit and proposes countermeasures. The UI testing unit automates user interface testing based on vulnerabilities detected by the vulnerability detection unit. [Effects of the Invention]

[0007] The system according to this embodiment can streamline the software development process and automatically detect and improve unnecessary processing and inefficient parts. [Brief explanation of the drawing]

[0008] [Figure 1] This is a conceptual diagram showing an example of the configuration of a data processing system according to the first embodiment. [Figure 2] This is a conceptual diagram showing an example of the essential functions of a data processing device and a smart device according to the first embodiment. [Figure 3] This is a conceptual diagram showing an example of the configuration of a data processing system according to the second embodiment. [Figure 4] This is a conceptual diagram showing an example of the main functions of a data processing device and smart glasses according to the second embodiment. [Figure 5] This is a conceptual diagram showing an example of the configuration of a data processing system according to the third embodiment. [Figure 6] This is a conceptual diagram showing an example of the main functions of a data processing device and a headset-type terminal according to the third embodiment. [Figure 7] This is a conceptual diagram showing an example of the configuration of a data processing system according to the fourth embodiment. [Figure 8]This is a conceptual diagram showing an example of the main functions of a data processing device and a robot according to the fourth embodiment. [Figure 9] This shows an emotion map where multiple emotions are mapped. [Figure 10] This shows an emotion map where multiple emotions are mapped. [Modes for carrying out the invention]

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

[0010] First, let's explain the terminology used in the following explanation.

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

[0012] In the following embodiments, signed RAM (Random Access Memory) is a memory that temporarily stores information and is used as work memory by the processor.

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

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

[0015] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B". That is, "A and / or B" means that it may be only A, only B, or a combination of A and B. Also, in this specification, when expressing three or more matters connected by "and / or", the same concept as "A and / or B" is applied.

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

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

[0018] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. 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. Also, the database 24 and the communication I / F 26 are 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).

[0019] 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. Also, the reception device 38, the output device 40, and the camera 42 are connected to the bus 52.

[0020] The reception device 38 includes a touch panel 38A and a microphone 38B, etc., and receives user input. The touch panel 38A receives user input by contact of an indicator (e.g., a pen or a finger, etc.) by detecting the contact of the indicator. The microphone 38B receives user input by voice by detecting the voice of the user. 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 (see FIG. 2) acquires data indicating the user input.

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

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

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

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

[0025] Storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290. The identification processing unit 290 can estimate the user's emotions using the emotion identification model 59 and perform identification processing using the user's emotions. The emotion estimation function (emotion identification function) using the emotion identification model 59 performs various estimations and predictions regarding the user's emotions, including but not limited to these examples. Furthermore, emotion estimation and prediction also include, for example, emotion analysis.

[0026] In the smart device 14, specific processing is performed by the processor 46. The storage 50 stores a specific processing program 60. The specific processing program 60 is used in conjunction with the specific processing program 56 by the data processing system 10. The processor 46 reads the specific processing program 60 from the storage 50 and executes the read specific processing program 60 on the RAM 48. The specific processing is realized by the processor 46 operating as a control unit 46A according to the specific processing program 60 executed on the RAM 48. The smart device 14 also has a data generation model 58 and an emotion identification model 59, similar to the data generation model and emotion identification model 59, and can perform processing similar to that of the specific processing unit 290 using these models.

[0027] Furthermore, other devices besides the data processing device 12 may also have the data generation model 58. For example, a server device (e.g., a generation server) may have the data generation model 58. In this case, the data processing device 12 obtains processing results (such as prediction results) using the data generation model 58 by communicating with the server device having the data generation model 58. The data processing device 12 may also be a server device or a terminal device owned by a user (e.g., a mobile phone, robot, home appliance, etc.). Next, an example of processing by the data processing system 10 according to the first embodiment will be described.

[0028] (Example of form 1) An integrated platform according to an embodiment of the present invention is a system that supports the software development process. This integrated platform performs static analysis of source code, automatically detects unnecessary processing and inefficiencies, and provides methods for improvement. It also features automatic test program generation and automatic documentation functions, generates relationship diagrams and transition diagrams, creates test cases based on specifications, provides vulnerability advice, and performs UI testing. This allows developers to concentrate solely on code creation. For example, the integrated platform first performs static analysis of the source code. In this process, the generating AI analyzes the source code and detects unnecessary processing and inefficient parts. For example, redundant loops and the use of unnecessary variables are detected. This improves code quality and enables efficient development. Next, the integrated platform automatically generates test programs. The generating AI creates test cases based on specifications and automatically generates test programs. For example, it creates test cases based on input data and expected output data, and generates test programs based on them. This improves testing efficiency and reduces the burden on developers. Furthermore, the integrated platform is equipped with an automatic documentation function. The generative AI automatically generates relationship diagrams and transition diagrams in response to changes and additions to the source code, creating development documentation. For example, class diagrams and sequence diagrams are automatically generated. This reduces the effort required for documentation creation and streamlines the development process. The integrated platform also provides vulnerability advice. The generative AI detects vulnerabilities in the source code and suggests countermeasures. For example, vulnerabilities such as SQL injection and cross-site scripting are detected, and countermeasures are suggested. This improves security. Finally, the integrated platform automates UI testing. The generative AI automates user interface testing, reducing manual effort. For example, button clicks and form inputs are automatically tested. This improves the efficiency of UI testing and reduces the burden on developers.Thus, the integrated platform of the present invention streamlines the software development process and provides an environment where developers can concentrate on writing code by performing static analysis of source code, automatic generation of test programs, automatic documentation, vulnerability advice, and automation of UI testing.

[0029] The integrated platform according to the embodiment comprises a static analysis unit, a test generation unit, a documentation generation unit, a vulnerability detection unit, and a UI testing unit. The static analysis unit performs static analysis of the source code. The static analysis unit analyzes the source code and detects unnecessary processing and inefficient parts. For example, the static analysis unit detects redundant loops and the use of unnecessary variables. The static analysis unit can also detect computationally intensive algorithms and redundant code. For example, the static analysis unit detects unnecessary loops in the source code and proposes replacing them with efficient loops. The static analysis unit can perform source code analysis using a generation AI. The generation AI takes the source code as input and outputs unnecessary processing and inefficient parts. The test generation unit automatically generates test programs based on the unnecessary processing and inefficient parts detected by the static analysis unit. The test generation unit creates test cases based on specifications and generates test programs. For example, the test generation unit creates test cases based on input data and expected output data and generates test programs based on them. The test generation unit can generate test programs using a generation AI. The generation AI takes specifications as input and outputs test cases and test programs. The documentation generation unit automatically generates relationship diagrams and transition diagrams based on the test programs generated by the test generation unit. The documentation generation unit automatically generates relationship diagrams and transition diagrams in response to changes or additions to the source code, and creates development documentation. For example, the documentation generation unit automatically generates class diagrams and sequence diagrams. The documentation generation unit can generate relationship diagrams and transition diagrams using the generation AI. The generation AI takes changes or additions to the source code as input and outputs relationship diagrams and transition diagrams. The vulnerability detection unit detects vulnerabilities based on the documentation generated by the documentation generation unit and proposes countermeasures. For example, the vulnerability detection unit detects vulnerabilities in the source code and proposes countermeasures. For example, the vulnerability detection unit detects vulnerabilities such as SQL injection and cross-site scripting and proposes countermeasures.The vulnerability detection unit can use generative AI to detect vulnerabilities and suggest countermeasures. The generative AI takes source code as input and outputs vulnerabilities and countermeasures. The UI testing unit automates user interface testing based on vulnerabilities detected by the vulnerability detection unit. The UI testing unit automates user interface testing, for example, reducing manual effort. For example, the UI testing unit automatically tests button clicks and form inputs. The UI testing unit can automate user interface testing using generative AI. The generative AI takes user interface operations as input and outputs test results. As a result, the integrated platform according to this embodiment can streamline the software development process and provide an environment where developers can concentrate on writing code.

[0030] The static analysis unit performs static analysis of source code. For example, it analyzes the source code to detect unnecessary processing and inefficient parts. Specifically, the static analysis unit analyzes the structure of the source code in detail to detect redundant loops and the use of unnecessary variables. For example, the static analysis unit identifies loops that are too deeply nested or sections with too many conditional branches and proposes ways to optimize them. It can also detect computationally intensive algorithms and redundant code. For example, the static analysis unit detects unnecessary loops in the source code and proposes replacing them with more efficient loops. Furthermore, the static analysis unit can analyze source code using generative AI. The generative AI takes source code as input and outputs unnecessary processing and inefficient parts. The generative AI uses natural language processing techniques to understand the context of the source code and generates specific suggestions for optimization. For example, the generative AI analyzes comments and function names in the source code, understands the intent of the code, and proposes the optimal refactoring method. In this way, the static analysis unit can improve the quality of source code and support developers in working more efficiently.

[0031] The test generation unit automatically generates test programs based on unnecessary processing and inefficient parts detected by the static analysis unit. Specifically, the test generation unit creates test cases based on the specifications and generates test programs. For example, the test generation unit creates test cases based on input data and expected output data, and generates test programs based on those. The test generation unit can also generate test programs using a generation AI. The generation AI takes the specifications as input and outputs test cases and test programs. The generation AI analyzes the natural language description in the specifications and extracts the information necessary for generating test cases. For example, the generation AI automatically extracts input conditions and expected outputs from the specifications and generates test cases based on them. In addition, the generation AI can learn from past test cases and test results to generate more effective test cases. As a result, the test generation unit can automatically generate efficient and high-quality test programs, significantly reducing the testing work of developers.

[0032] The documentation generation unit automatically generates relationship diagrams and transition diagrams based on test programs generated by the test generation unit. Specifically, the documentation generation unit automatically generates relationship diagrams and transition diagrams in response to changes and additions to the source code, creating development documentation. For example, the documentation generation unit automatically generates class diagrams and sequence diagrams. The documentation generation unit can generate relationship diagrams and transition diagrams using a generation AI. The generation AI takes changes and additions to the source code as input and outputs relationship diagrams and transition diagrams. The generation AI analyzes the structure of the source code and understands the relationships between classes and the order of method calls. For example, the generation AI analyzes the class definitions and method definitions in the source code and generates a class diagram based on their relationships. The generation AI also analyzes the order of method calls and generates a sequence diagram. As a result, the documentation generation unit can always maintain the latest development documentation in response to changes and additions to the source code by the developer. Furthermore, the documentation generation unit can automatically register the generated documents in a version control system and manage the change history. This allows developers to easily refer to past change histories and improve transparency in the development process.

[0033] The vulnerability detection unit detects vulnerabilities based on documents generated by the documentation generation unit and proposes countermeasures. Specifically, the vulnerability detection unit detects vulnerabilities in the source code and proposes countermeasures. For example, the vulnerability detection unit detects vulnerabilities such as SQL injection and cross-site scripting and proposes countermeasures. The vulnerability detection unit can use a generation AI to detect vulnerabilities and propose countermeasures. The generation AI takes source code as input and outputs vulnerabilities and countermeasures. The generation AI learns vulnerability patterns and automatically identifies vulnerable areas in the source code. For example, the generation AI analyzes the structure of SQL queries and identifies areas at risk of SQL injection. The generation AI also analyzes HTML and JavaScript (registered trademark) code and identifies areas at risk of cross-site scripting. Furthermore, the generation AI proposes specific countermeasures for the detected vulnerabilities. For example, the generation AI suggests using parameterized queries as a countermeasure against SQL injection. It also suggests escaping input data as a countermeasure against cross-site scripting. This allows the vulnerability detection unit to improve the security of the source code and assist developers in creating secure code.

[0034] The UI Testing Department automates user interface testing based on vulnerabilities detected by the Vulnerability Detection Department. Specifically, the UI Testing Department automates user interface testing, reducing manual effort. For example, the UI Testing Department automatically tests button clicks and form inputs. The UI Testing Department can automate user interface testing using generative AI. The generative AI takes user interface operations as input and outputs test results. The generative AI learns user interface operation patterns and generates efficient test scenarios. For example, the generative AI learns typical user operation sequences and generates test scenarios based on them. The generative AI can also generate test scenarios that consider abnormal operations and edge cases. This allows the UI Testing Department to improve the quality of the user interface and enhance the user experience. Furthermore, the UI Testing Department automatically reports test results and provides feedback to developers. For example, the UI Testing Department reports the success rate of tests and details of failed test cases, helping developers quickly identify and fix problems. This allows the UI testing department to streamline the user interface testing process and support developers in delivering high-quality software.

[0035] The static analysis unit can analyze source code and detect unnecessary processing and inefficient parts. For example, the static analysis unit can analyze source code and detect redundant loops and the use of unnecessary variables. For example, the static analysis unit can detect redundant loops and suggest replacing them with more efficient loops. The static analysis unit can also detect computationally intensive algorithms and redundant code. For example, the static analysis unit can detect computationally intensive algorithms and suggest replacing them with more efficient algorithms. The static analysis unit can also detect redundant code and suggest replacing it with more concise code. By detecting unnecessary processing and inefficient parts of the source code, the quality of the code is improved and efficient development becomes possible. Some or all of the above processing in the static analysis unit may be performed using a generative AI, or it may be performed without a generative AI. For example, the static analysis unit can input source code into a generative AI and have the generative AI perform the detection of unnecessary processing and inefficient parts.

[0036] The test generation unit can create test cases and generate test programs based on the specifications. For example, the test generation unit can create test cases based on input data and expected output data based on the specifications, and generate test programs based on those test cases. For example, the test generation unit can create test cases and generate test programs based on the functional requirements described in the specifications. The test generation unit can also create test cases and generate test programs based on the non-functional requirements described in the specifications. For example, the test generation unit can create load test cases and generate test programs based on performance requirements. The test generation unit can also create security test cases and generate test programs based on security requirements. By creating test cases and generating test programs based on the specifications, the efficiency of testing is improved and the burden on developers is reduced. Some or all of the above-described processes in the test generation unit may be performed using a generation AI, or they may be performed without a generation AI. For example, the test generation unit can input the specifications into a generation AI and have the generation AI execute the generation of test cases and test programs.

[0037] The documentation generation unit can automatically generate relationship diagrams and transition diagrams in response to changes and additions to the source code, thereby creating development documentation. For example, the documentation generation unit can automatically generate class diagrams and sequence diagrams in response to changes and additions to the source code. For example, the documentation generation unit can automatically generate a class diagram based on changes to the source code, highlighting the changes. The documentation generation unit can also automatically generate a sequence diagram based on additions to the source code, and can add new sequences. For example, the documentation generation unit can generate a class diagram that highlights the changes by referring to the source code change history. The documentation generation unit can also generate a sequence diagram that adds new sequences by referring to the source code addition history. As a result, by automatically generating relationship diagrams and transition diagrams in response to changes and additions to the source code, and creating development documentation, the effort required for documentation creation is reduced, and the development process is made more efficient. Some or all of the above-described processes in the documentation generation unit may be performed using a generation AI, or they may be performed without using a generation AI. For example, the documentation generation unit can input changes and additions to the source code into the generation AI, and have the generation AI execute the generation of relationship diagrams and transition diagrams.

[0038] The vulnerability detection unit can detect vulnerabilities in the source code and suggest countermeasures. For example, the vulnerability detection unit can detect vulnerabilities such as SQL injection and cross-site scripting in the source code and suggest countermeasures. For example, the vulnerability detection unit can detect an SQL injection vulnerability and suggest the use of parameterized queries. The vulnerability detection unit can also detect a cross-site scripting vulnerability and suggest escaping the input data. For example, the vulnerability detection unit can detect vulnerabilities in the source code and suggest specific code modifications. The vulnerability detection unit can also suggest applying security patches. This improves security by detecting vulnerabilities in the source code and suggesting countermeasures. Some or all of the above processing in the vulnerability detection unit may be performed using a generative AI, or it may be performed without a generative AI. For example, the vulnerability detection unit can input the source code into a generative AI and have the generative AI perform vulnerability detection and suggest countermeasures.

[0039] The UI testing unit can automate user interface testing, reducing manual effort. For example, the UI testing unit can automatically test button clicks and form inputs in the user interface. For instance, it can automatically test button clicks to verify correct operation. It can also automatically test form input to verify that input data is processed correctly. Furthermore, it can automatically test screen transitions in the user interface to verify correct transitions. Finally, it can automatically test the content displayed in the user interface to verify that it is displayed correctly. This automates user interface testing and reduces manual effort, improving the efficiency of UI testing and reducing the burden on developers. Some or all of the above-described processes in the UI testing unit may be performed using or without a generative AI. For example, the UI testing unit can input user interface operations into a generative AI and have the generative AI generate the test results.

[0040] The static analysis unit can analyze the change history of source code and identify inefficient parts created by specific developers. For example, the static analysis unit can analyze parts that a specific developer has frequently modified and identify inefficient code patterns. For example, the static analysis unit can analyze parts that a specific developer has frequently modified and identify redundant code or computationally intensive algorithms. The static analysis unit can also evaluate the quality of code created by a specific developer based on the change history and suggest areas for improvement. For example, the static analysis unit can evaluate the quality of code created by a specific developer and suggest specific areas for improvement. The static analysis unit can also analyze the change history and identify inefficiencies in the entire project in which a specific developer was involved. For example, the static analysis unit can identify inefficiencies in the entire project in which a specific developer was involved and suggest areas for improvement. In this way, by analyzing the change history of source code and identifying inefficient parts created by specific developers, areas for improvement by the developers are clarified, and the quality of the code is improved. Some or all of the above processing in the static analysis unit may be performed using generative AI, or it may be performed without using generative AI. For example, the static analysis unit can input the source code change history into the generation AI and have the generation AI identify inefficient parts.

[0041] The static analysis unit can evaluate the complexity of the source code and perform detailed analysis on particularly complex parts. For example, the static analysis unit can evaluate the complexity of the source code using metrics and identify particularly complex parts. For example, the static analysis unit can evaluate the cyclomatic complexity of the source code and identify particularly complex parts. The static analysis unit can also perform detailed analysis on complex parts and suggest specific areas for improvement. For example, the static analysis unit can collect detailed debugging information on complex parts and suggest specific areas for improvement. The static analysis unit can also visually highlight highly complex parts to draw the developer's attention. For example, the static analysis unit can color-code highly complex parts to draw the developer's attention. In this way, by evaluating the complexity of the source code and performing detailed analysis on particularly complex parts, specific areas for improvement can be suggested, thereby improving the quality of the code. Some or all of the above processes in the static analysis unit may be performed using a generative AI, or they may be performed without a generative AI. For example, the static analysis unit can input the complexity of the source code into a generative AI and have the generative AI perform the identification of particularly complex parts and detailed analysis.

[0042] The static analysis unit can adjust the depth of its analysis when analyzing source code, taking into account the progress of the development project. For example, in the early stages of a project, the static analysis unit can perform an analysis that emphasizes overall code quality. For example, in the early stages of a project, the static analysis unit can evaluate the overall code quality and suggest areas for improvement. In the middle stages of a project, the static analysis unit can also perform a detailed analysis focusing on specific functions. For example, in the middle stages of a project, the static analysis unit can perform a detailed analysis focusing on specific functions and suggest specific areas for improvement. Furthermore, in the final stages of a project, the static analysis unit can perform a rigorous analysis for final quality assurance. For example, in the final stages of a project, the static analysis unit can perform a rigorous analysis for final quality assurance and suggest final areas for improvement. This allows for appropriate analysis at each stage of the project by adjusting the depth of the analysis in consideration of the progress of the development project. Some or all of the above-described processes in the static analysis unit may be performed using a generative AI, or they may be performed without a generative AI. For example, the static analysis unit can input the progress of the development project into the generative AI and have the generative AI adjust the depth of the analysis.

[0043] The static analysis unit can identify inefficient parts of source code by comparing it with codebases from other projects. For example, it can identify common inefficient patterns by comparing it with codebases from other projects. For example, it can identify redundant code or computationally intensive algorithms by comparing it with codebases from other projects. The static analysis unit can also improve inefficient parts by referring to best practices from other projects. For example, it can replace inefficient parts with more efficient code by referring to best practices from other projects. The static analysis unit can also visually highlight specific inefficient parts by comparing them with codebases from other projects. For example, it can color-code specific inefficient parts when comparing them with codebases from other projects. This allows for the identification of inefficient parts by comparing them with codebases from other projects, thereby improving common inefficient patterns and enhancing code quality. Some or all of the above processes in the static analysis unit may be performed using or without a generative AI. For example, the static analysis unit can input codebases from other projects into a generative AI and have the generative AI identify inefficient parts.

[0044] The test generation unit can create test cases that reproduce specific bugs by referring to past bug history when generating test cases. For example, the test generation unit generates test cases that reproduce specific bugs based on past bug history. For example, the test generation unit generates test cases that reproduce specific bugs based on past bug history to prevent recurrence. The test generation unit can also analyze bug history and prioritize the generation of test cases for bugs that are likely to recur. For example, the test generation unit analyzes bug history and prioritizes the generation of test cases for bugs that are likely to recur. The test generation unit can also refer to bug history to generate detailed test cases for specific bugs. For example, the test generation unit refers to bug history to generate detailed test cases for specific bugs to prevent recurrence. In this way, by creating test cases that reproduce specific bugs by referring to past bug history, testing for bugs that are likely to recur is strengthened and quality is improved. Some or all of the above processes in the test generation unit may be performed using generation AI, or they may be performed without using generation AI. For example, the test generation unit can input past bug history into the generation AI and have the AI ​​generate test cases that reproduce a specific bug.

[0045] The test generation unit can determine which parts of the code to focus on testing based on the code changes when generating test cases. For example, the test generation unit can identify the code changes and prioritize generating test cases for those parts. For example, the test generation unit can identify the code changes, prioritize generating test cases for those parts, and verify the impact of the changes. The test generation unit can also analyze the scope of impact of the changes and generate test cases for the relevant parts. For example, the test generation unit can analyze the scope of impact of the changes and generate test cases for the relevant parts. The test generation unit can also determine the priority of test cases based on the importance of the changes. For example, the test generation unit determines the priority of test cases based on the importance of the changes and prioritizes testing the important parts. This allows for effective testing that takes into account the impact of the changes by determining which parts of the code to focus on testing based on the code changes. Some or all of the above processes in the test generation unit may be performed using a generation AI, or they may be performed without using a generation AI. For example, the test generation unit can input code changes into the generation AI and have the AI ​​determine which parts to focus on when testing.

[0046] The test generation unit can adjust the difficulty of test cases when generating them, taking into account the developer's skill level. For example, the test generation unit can generate a balanced mix of easy and difficult test cases according to the developer's skill level. For instance, it can prioritize generating easy-to-understand test cases for developers with lower skill levels. It can also generate detailed and complex test cases for developers with higher skill levels. For example, it can generate detailed and complex test cases for developers with higher skill levels to promote deeper understanding. By adjusting the difficulty of test cases to account for the developer's skill level, the test generation unit can provide appropriate test cases for developers. Some or all of the above processing in the test generation unit may be performed using a generation AI, or it may be performed without a generation AI. For example, the test generation unit can input the developer's skill level into the generation AI and have the generation AI adjust the difficulty of the test cases.

[0047] The test generation unit can create new test cases by referencing test cases from other projects. For example, the test generation unit can reference test cases from other projects to generate common test cases, thereby improving testing efficiency. The test generation unit can also create new test cases by referencing best practices from other projects, thereby improving quality. Furthermore, the test generation unit can analyze test cases from other projects, improve specific test cases, and generate them, thereby improving quality. In this way, by referencing test cases from other projects, common test cases can be generated, improving testing efficiency. Some or all of the above processes in the test generation unit may be performed using a generation AI, or they may not be performed using a generation AI. For example, the test generation unit can input test cases from other projects into a generation AI and have the generation AI create new test cases.

[0048] The documentation generation unit can refer to the code change history and highlight changes when generating documentation. For example, the documentation generation unit generates documentation that highlights changes based on the code change history. For example, the documentation generation unit generates documentation that highlights changes using color coding based on the code change history. The documentation generation unit can also refer to the change history and generate documentation that includes detailed explanations of changes. For example, the documentation generation unit refers to the change history and generates documentation that includes detailed explanations of changes. The documentation generation unit can also visually display the change history and generate documentation that highlights changes. For example, the documentation generation unit visually displays the change history using graphs or charts and generates documentation that highlights changes. This allows developers to quickly grasp changes by referring to the code change history and highlighting the changes. Some or all of the above processes in the documentation generation unit may be performed using generation AI, or they may not be performed using generation AI. For example, the documentation generation unit can input the code change history into the generation AI and have the AI ​​generate documentation that highlights the changes.

[0049] The documentation generation unit can automatically generate documents tailored to specific development phases during document generation. For example, in the early stages of a project, the documentation generation unit can generate an overall design document, indicating the direction of the project. The documentation generation unit can also generate a detailed design document in the middle stages of a project, showing specific implementation methods. Furthermore, the documentation generation unit can generate the final release document in the final stages of a project, preparing for release. This allows for the provision of documents suitable for the development process by automatically generating documents tailored to specific development phases. Some or all of the above-described processes in the documentation generation unit may be performed using a generation AI, or they may not be performed using a generation AI. For example, the documentation generation unit can input a specific development phase into a generation AI and have the generation AI perform the automatic document generation.

[0050] The documentation generation unit can generate different documents depending on the developer's role during document generation. For example, the documentation generation unit can generate technical documents for developers. For example, it can generate documents containing technical details for developers and provide them in a format that is easy for developers to understand. The documentation generation unit can also generate progress report documents for project managers. For example, it can generate documents reporting the progress for project managers and provide them in a format that makes it easy to understand the project's progress. The documentation generation unit can also generate test case documents for testers. For example, it can generate documents containing test case details for testers to support the execution of tests. In this way, by generating different documents depending on the developer's role, information appropriate to each role can be provided. Some or all of the above processes in the documentation generation unit may be performed using a generation AI, or they may not be performed using a generation AI. For example, the documentation generation unit can input the developer's role into the generation AI and have the generation AI execute the generation of different documents.

[0051] The documentation generation unit can create new documents by referencing documents from other projects during document generation. For example, the documentation generation unit can reference documents from other projects to generate common documents. For example, the documentation generation unit can reference documents from other projects to generate common documents and improve the efficiency of document creation. The documentation generation unit can also create new documents by referencing best practices from other projects. For example, the documentation generation unit can reference best practices from other projects to create new documents and improve their quality. The documentation generation unit can also analyze documents from other projects and improve specific documents before generating them. For example, the documentation generation unit can analyze documents from other projects, improve specific documents before generating them, and improve their quality. This allows for the generation of common documents by referencing documents from other projects, thereby improving the efficiency of document creation. Some or all of the above processes in the documentation generation unit may be performed using generation AI, or they may not be performed using generation AI. For example, the documentation generation unit can input documents from other projects into the generation AI and have the generation AI create new documents.

[0052] The vulnerability detection unit can, when detecting a vulnerability, refer to past vulnerability history to focus on detecting specific vulnerabilities. For example, the vulnerability detection unit can focus on detecting vulnerabilities that are likely to recur based on past vulnerability history. For example, the vulnerability detection unit can focus on detecting vulnerabilities that are likely to recur based on past vulnerability history to prevent recurrence. The vulnerability detection unit can also analyze vulnerability history and provide detailed detection methods for specific vulnerabilities. For example, the vulnerability detection unit can analyze vulnerability history and provide detailed detection methods for specific vulnerabilities. The vulnerability detection unit can also refer to vulnerability history to perform focused detection on specific vulnerabilities. For example, the vulnerability detection unit can refer to vulnerability history to perform focused detection on specific vulnerabilities to prevent recurrence. By referring to past vulnerability history to focus on detecting specific vulnerabilities, the detection of vulnerabilities that are likely to recur is strengthened, and security is improved. Some or all of the above processing in the vulnerability detection unit may be performed using a generation AI, or it may be performed without a generation AI. For example, the vulnerability detection unit can input past vulnerability history into a generation AI and have the generation AI execute a process to focus on detecting specific vulnerabilities.

[0053] The vulnerability detection unit can determine which parts to focus on detecting vulnerabilities based on the code changes. For example, the vulnerability detection unit can identify the code changes and prioritize vulnerability detection in those parts. For example, the vulnerability detection unit can identify the code changes, prioritize vulnerability detection in those parts, and confirm the impact of the changes. The vulnerability detection unit can also analyze the scope of impact of the changes and perform vulnerability detection in related parts. For example, the vulnerability detection unit can analyze the scope of impact of the changes and perform vulnerability detection in related parts. The vulnerability detection unit can also determine the priority of vulnerability detection based on the importance of the changes. For example, the vulnerability detection unit determines the priority of vulnerability detection based on the importance of the changes and prioritizes detection in important parts. This allows for effective vulnerability detection that takes into account the impact of the changes by determining which parts to focus on detecting based on the code changes. Some or all of the above processing in the vulnerability detection unit may be performed using generative AI, or it may be performed without using generative AI. For example, the vulnerability detection unit can input code changes into a generating AI and have the AI ​​determine which parts to focus on for detection.

[0054] The vulnerability detection unit can adjust how vulnerabilities are presented when vulnerabilities are detected, taking into account the developer's skill level. For example, the vulnerability detection unit can present vulnerabilities to developers with low skill levels in an easy-to-understand format. For example, the vulnerability detection unit can present vulnerabilities to developers with low skill levels in a visually easy-to-understand format using graphs and charts. The vulnerability detection unit can also provide detailed vulnerability information to developers with high skill levels. For example, the vulnerability detection unit can provide vulnerability information to developers with high skill levels using a detailed text report. Furthermore, the vulnerability detection unit can customize how vulnerabilities are presented according to the skill level. For example, the vulnerability detection unit can customize how vulnerabilities are presented according to the skill level and provide them in a format that is easy for developers to understand. In this way, by adjusting the method of presenting vulnerabilities to take into account the developer's skill level, vulnerabilities can be provided in a format that is easy for developers to understand. Some or all of the above processing in the vulnerability detection unit may be performed using a generative AI, or it may be performed without using a generative AI. For example, the vulnerability detection unit can input the developer's skill level into a generative AI and have the generative AI perform the adjustment of the vulnerability presentation method.

[0055] The vulnerability detection unit can detect new vulnerabilities by referring to vulnerability information from other projects when detecting vulnerabilities. For example, the vulnerability detection unit can refer to vulnerability information from other projects to detect common vulnerabilities. For example, the vulnerability detection unit can refer to vulnerability information from other projects to detect common vulnerabilities and improve security. The vulnerability detection unit can also detect new vulnerabilities by referring to best practices from other projects. For example, the vulnerability detection unit can refer to best practices from other projects to detect new vulnerabilities and improve security. The vulnerability detection unit can also analyze vulnerability information from other projects and improve specific vulnerabilities for detection. For example, the vulnerability detection unit can analyze vulnerability information from other projects, improve specific vulnerabilities for detection, and improve security. In this way, by referring to vulnerability information from other projects, common vulnerabilities can be detected and security improved. Some or all of the above processing in the vulnerability detection unit may be performed using a generative AI, or it may be performed without a generative AI. For example, the vulnerability detection unit can input vulnerability information from other projects into a generative AI and have the generative AI perform the detection of new vulnerabilities.

[0056] The UI testing department can perform tests to reproduce specific bugs by referring to past UI bug history during UI testing. For example, the UI testing department can perform tests to reproduce specific bugs based on past UI bug history. For example, the UI testing department can perform tests to reproduce specific bugs based on past UI bug history to prevent recurrence. The UI testing department can also analyze bug history and prioritize testing for bugs that are prone to recurrence. For example, the UI testing department analyzes bug history and prioritizes testing for bugs that are prone to recurrence. The UI testing department can also perform detailed tests for specific bugs by referring to bug history. For example, the UI testing department can perform detailed tests for specific bugs by referring to bug history to prevent recurrence. In this way, by performing tests to reproduce specific bugs by referring to past UI bug history, testing for bugs that are prone to recurrence is strengthened and quality is improved. Some or all of the above processes in the UI testing department may be performed using a generative AI, or not. For example, the UI testing department can input past UI bug history into a generative AI and have the generative AI execute tests to reproduce specific bugs.

[0057] The UI testing unit can determine which parts to focus on testing by referring to the user's operation history during UI testing. For example, the UI testing unit can focus on testing frequently used parts based on the user's operation history. For example, the UI testing unit can focus on testing frequently used parts based on the user's operation history to improve the quality of those parts. The UI testing unit can also analyze the operation history and prioritize testing of important operations. For example, the UI testing unit can analyze the operation history and prioritize testing of important operations. The UI testing unit can also refer to the operation history to conduct detailed testing of specific operations. For example, the UI testing unit can refer to the operation history to conduct detailed testing of specific operations to improve quality. In this way, by determining which parts to focus on testing by referring to the user's operation history, testing of frequently used parts is strengthened and quality is improved. Some or all of the above processes in the UI testing unit may be performed using generative AI, or not. For example, the UI testing unit can input the user's operation history into generative AI and have the generative AI determine which parts to focus on testing.

[0058] The UI testing unit can adjust its testing methods when conducting UI tests, taking into account the user's device information. For example, if the user is using a smartphone, the UI testing unit can conduct tests tailored to the screen size to confirm the user experience on a smartphone. Similarly, if the user is using a tablet, the UI testing unit can conduct tests optimized for larger screens to confirm the user experience on a tablet. Furthermore, if the user is using a smartwatch, the UI testing unit can conduct concise and highly visible tests to confirm the user experience on a smartwatch. This allows the UI testing unit to provide UI tests optimized for each device by adjusting the testing methods based on the user's device information. Some or all of the above-described processes in the UI testing unit may be performed using or without a generative AI. For example, the UI testing unit can input the user's device information into a generative AI and have the generative AI adjust the testing methods.

[0059] The UI testing department can create new test cases by referencing UI test cases from other projects during UI testing. For example, the UI testing department can refer to UI test cases from other projects to generate common test cases, thereby improving testing efficiency. The UI testing department can also create new UI test cases by referencing best practices from other projects, thereby improving quality. Furthermore, the UI testing department can analyze UI test cases from other projects, improve specific test cases, and generate them, thereby improving quality. In this way, by referencing UI test cases from other projects, common test cases can be generated, improving testing efficiency. Some or all of the above processes in the UI testing department may be performed using a generation AI, or not. For example, the UI testing department can input UI test cases from other projects into a generation AI and have the generation AI create new test cases.

[0060] The system according to the embodiment is not limited to the example described above, and various modifications are possible, for example, as follows.

[0061] The integrated platform can further include features to assess developers' skill levels and provide support tailored to those skill levels. For example, it can provide novice developers with basic coding guidelines and simple tasks to support their skill development. It can also provide experienced developers with complex problem-solving and advanced technical advice. Furthermore, it can suggest appropriate learning resources and training programs based on the developer's skill level. This promotes efficient learning and growth by providing support tailored to the developer's skill level, improving the overall quality of the development process. Skill level assessment may or may not be performed using generative AI. For example, the integrated platform can input developer skill data into a generative AI, allowing the AI ​​to perform skill level assessment and provide support.

[0062] The integrated platform can also include the ability to monitor the progress of development projects in real time and provide feedback based on progress. For example, if a project is behind schedule, the platform can identify the cause of the delay and suggest solutions. If progress is on track, it can also provide advice and resources for moving to the next step. Furthermore, it can provide tools to facilitate communication among team members and strengthen collaboration, depending on the project's progress. This supports project success and enables efficient development by monitoring the progress of development projects in real time and providing appropriate feedback. Progress monitoring may or may not be performed using generative AI. For example, the integrated platform can input project progress data into a generative AI and have the generative AI provide feedback.

[0063] The integrated platform can further incorporate features to optimize the developer's work environment. For example, it can analyze the developer's work patterns and suggest optimal work and break times. It can also adjust physical elements of the work environment, such as temperature and lighting, to provide a comfortable working environment. Furthermore, it can provide music or white noise to enhance the developer's concentration. By optimizing the developer's work environment, it supports efficient work and improves the overall quality of the development process. This optimization of the work environment may or may not be performed using generative AI. For example, the integrated platform can input developer work data into a generative AI and have the generative AI perform the optimization of the work environment.

[0064] The integrated platform can also include features to monitor the developer's health and provide support tailored to their health status. For example, it can monitor the developer's heart rate and stress level, and suggest a break if their health deteriorates. If their health is good, it can also provide tasks to improve their concentration. Furthermore, it can provide advice on appropriate exercise and relaxation based on the developer's health status. This allows for a healthier work environment and improves the overall efficiency of the development process by monitoring the developer's health and providing appropriate support. Health monitoring may be performed using generative AI or not. For example, the integrated platform can input the developer's health data into a generative AI and have the generative AI provide support.

[0065] The integrated platform can further incorporate the ability to analyze developers' work history and suggest efficient work patterns. For example, it can suggest the most efficient work times and task sequences based on past work history. It can also analyze work history to identify frequently occurring problems and bottlenecks and suggest solutions. Furthermore, it can suggest resources and training programs that help improve developers' skills based on their work history. By analyzing developers' work history and suggesting efficient work patterns, it improves work efficiency and the overall quality of the development process. The analysis of work history may be performed using generative AI or not. For example, the integrated platform can input work history data into a generative AI and have the generative AI suggest efficient work patterns.

[0066] The integrated platform can also include features to provide guidelines to further improve developers' work efficiency. For example, it can suggest efficient coding styles and best practices to support developers in working efficiently. It can also provide tools and resources to improve work efficiency. Furthermore, it can monitor developers' work efficiency and provide feedback on areas for improvement. In this way, by providing guidelines to improve developers' work efficiency, it supports efficient work and improves the quality of the entire development process. The provision of guidelines may or may not be done using generative AI. For example, the integrated platform can input work efficiency data into a generative AI and have the generative AI provide the guidelines.

[0067] The following briefly describes the processing flow for example form 1.

[0068] Step 1: The static analysis unit performs static analysis of the source code to detect unnecessary processing and inefficient parts. For example, it detects redundant loops, the use of unnecessary variables, computationally intensive algorithms, and redundant code. Source code analysis can also be performed using generative AI. Step 2: The test generation unit automatically generates test programs based on the unnecessary processing and inefficient parts detected by the static analysis unit. For example, it creates test cases based on the specifications and generates test programs based on input data and expected output data. Test programs can also be generated using generation AI. Step 3: The documentation generation unit automatically generates relationship diagrams and transition diagrams based on the test programs generated by the test generation unit. For example, it automatically generates class diagrams and sequence diagrams in response to changes or additions to the source code, creating development documentation. It is also possible to generate relationship diagrams and transition diagrams using generation AI. Step 4: The vulnerability detection unit detects vulnerabilities based on the documentation generated by the documentation generation unit and proposes countermeasures. For example, it detects vulnerabilities such as SQL injection and cross-site scripting and proposes countermeasures. It is also possible to use generation AI to detect vulnerabilities and propose countermeasures. Step 5: The UI testing unit automates user interface testing based on vulnerabilities detected by the vulnerability detection unit. For example, it automates button clicks and form inputs, reducing manual effort. User interface testing can also be automated using generative AI.

[0069] (Example of form 2) An integrated platform according to an embodiment of the present invention is a system that supports the software development process. This integrated platform performs static analysis of source code, automatically detects unnecessary processing and inefficiencies, and provides methods for improvement. It also features automatic test program generation and automatic documentation functions, generates relationship diagrams and transition diagrams, creates test cases based on specifications, provides vulnerability advice, and performs UI testing. This allows developers to concentrate solely on code creation. For example, the integrated platform first performs static analysis of the source code. In this process, the generating AI analyzes the source code and detects unnecessary processing and inefficient parts. For example, redundant loops and the use of unnecessary variables are detected. This improves code quality and enables efficient development. Next, the integrated platform automatically generates test programs. The generating AI creates test cases based on specifications and automatically generates test programs. For example, it creates test cases based on input data and expected output data, and generates test programs based on them. This improves testing efficiency and reduces the burden on developers. Furthermore, the integrated platform is equipped with an automatic documentation function. The generative AI automatically generates relationship diagrams and transition diagrams in response to changes and additions to the source code, creating development documentation. For example, class diagrams and sequence diagrams are automatically generated. This reduces the effort required for documentation creation and streamlines the development process. The integrated platform also provides vulnerability advice. The generative AI detects vulnerabilities in the source code and suggests countermeasures. For example, vulnerabilities such as SQL injection and cross-site scripting are detected, and countermeasures are suggested. This improves security. Finally, the integrated platform automates UI testing. The generative AI automates user interface testing, reducing manual effort. For example, button clicks and form inputs are automatically tested. This improves the efficiency of UI testing and reduces the burden on developers.Thus, the integrated platform of the present invention streamlines the software development process and provides an environment where developers can concentrate on writing code by performing static analysis of source code, automatic generation of test programs, automatic documentation, vulnerability advice, and automation of UI testing.

[0070] The integrated platform according to the embodiment comprises a static analysis unit, a test generation unit, a documentation generation unit, a vulnerability detection unit, and a UI testing unit. The static analysis unit performs static analysis of the source code. The static analysis unit analyzes the source code and detects unnecessary processing and inefficient parts. For example, the static analysis unit detects redundant loops and the use of unnecessary variables. The static analysis unit can also detect computationally intensive algorithms and redundant code. For example, the static analysis unit detects unnecessary loops in the source code and proposes replacing them with efficient loops. The static analysis unit can perform source code analysis using a generation AI. The generation AI takes the source code as input and outputs unnecessary processing and inefficient parts. The test generation unit automatically generates test programs based on the unnecessary processing and inefficient parts detected by the static analysis unit. The test generation unit creates test cases based on specifications and generates test programs. For example, the test generation unit creates test cases based on input data and expected output data and generates test programs based on them. The test generation unit can generate test programs using a generation AI. The generation AI takes specifications as input and outputs test cases and test programs. The documentation generation unit automatically generates relationship diagrams and transition diagrams based on the test programs generated by the test generation unit. The documentation generation unit automatically generates relationship diagrams and transition diagrams in response to changes or additions to the source code, and creates development documentation. For example, the documentation generation unit automatically generates class diagrams and sequence diagrams. The documentation generation unit can generate relationship diagrams and transition diagrams using the generation AI. The generation AI takes changes or additions to the source code as input and outputs relationship diagrams and transition diagrams. The vulnerability detection unit detects vulnerabilities based on the documentation generated by the documentation generation unit and proposes countermeasures. For example, the vulnerability detection unit detects vulnerabilities in the source code and proposes countermeasures. For example, the vulnerability detection unit detects vulnerabilities such as SQL injection and cross-site scripting and proposes countermeasures.The vulnerability detection unit can use generative AI to detect vulnerabilities and suggest countermeasures. The generative AI takes source code as input and outputs vulnerabilities and countermeasures. The UI testing unit automates user interface testing based on vulnerabilities detected by the vulnerability detection unit. The UI testing unit automates user interface testing, for example, reducing manual effort. For example, the UI testing unit automatically tests button clicks and form inputs. The UI testing unit can automate user interface testing using generative AI. The generative AI takes user interface operations as input and outputs test results. As a result, the integrated platform according to this embodiment can streamline the software development process and provide an environment where developers can concentrate on writing code.

[0071] The static analysis unit performs static analysis of source code. For example, it analyzes the source code to detect unnecessary processing and inefficient parts. Specifically, the static analysis unit analyzes the structure of the source code in detail to detect redundant loops and the use of unnecessary variables. For example, the static analysis unit identifies loops that are too deeply nested or sections with too many conditional branches and proposes ways to optimize them. It can also detect computationally intensive algorithms and redundant code. For example, the static analysis unit detects unnecessary loops in the source code and proposes replacing them with more efficient loops. Furthermore, the static analysis unit can analyze source code using generative AI. The generative AI takes source code as input and outputs unnecessary processing and inefficient parts. The generative AI uses natural language processing techniques to understand the context of the source code and generates specific suggestions for optimization. For example, the generative AI analyzes comments and function names in the source code, understands the intent of the code, and proposes the optimal refactoring method. In this way, the static analysis unit can improve the quality of source code and support developers in working more efficiently.

[0072] The test generation unit automatically generates test programs based on unnecessary processing and inefficient parts detected by the static analysis unit. Specifically, the test generation unit creates test cases based on the specifications and generates test programs. For example, the test generation unit creates test cases based on input data and expected output data, and generates test programs based on those. The test generation unit can also generate test programs using a generation AI. The generation AI takes the specifications as input and outputs test cases and test programs. The generation AI analyzes the natural language description in the specifications and extracts the information necessary for generating test cases. For example, the generation AI automatically extracts input conditions and expected outputs from the specifications and generates test cases based on them. In addition, the generation AI can learn from past test cases and test results to generate more effective test cases. As a result, the test generation unit can automatically generate efficient and high-quality test programs, significantly reducing the testing work of developers.

[0073] The documentation generation unit automatically generates relationship diagrams and transition diagrams based on test programs generated by the test generation unit. Specifically, the documentation generation unit automatically generates relationship diagrams and transition diagrams in response to changes and additions to the source code, creating development documentation. For example, the documentation generation unit automatically generates class diagrams and sequence diagrams. The documentation generation unit can generate relationship diagrams and transition diagrams using a generation AI. The generation AI takes changes and additions to the source code as input and outputs relationship diagrams and transition diagrams. The generation AI analyzes the structure of the source code and understands the relationships between classes and the order of method calls. For example, the generation AI analyzes the class definitions and method definitions in the source code and generates a class diagram based on their relationships. The generation AI also analyzes the order of method calls and generates a sequence diagram. As a result, the documentation generation unit can always maintain the latest development documentation in response to changes and additions to the source code by the developer. Furthermore, the documentation generation unit can automatically register the generated documents in a version control system and manage the change history. This allows developers to easily refer to past change histories and improve transparency in the development process.

[0074] The vulnerability detection unit detects vulnerabilities based on documents generated by the documentation generation unit and proposes countermeasures. Specifically, the vulnerability detection unit detects vulnerabilities in the source code and proposes countermeasures. For example, the vulnerability detection unit detects vulnerabilities such as SQL injection and cross-site scripting and proposes countermeasures. The vulnerability detection unit can use a generation AI to detect vulnerabilities and propose countermeasures. The generation AI takes source code as input and outputs vulnerabilities and countermeasures. The generation AI learns vulnerability patterns and automatically identifies vulnerable areas in the source code. For example, the generation AI analyzes the structure of SQL queries and identifies areas at risk of SQL injection. The generation AI also analyzes HTML and JavaScript code and identifies areas at risk of cross-site scripting. Furthermore, the generation AI proposes specific countermeasures for the detected vulnerabilities. For example, the generation AI suggests using parameterized queries as a countermeasure against SQL injection. It also suggests escaping input data as a countermeasure against cross-site scripting. This allows the vulnerability detection unit to improve the security of the source code and assist developers in creating secure code.

[0075] The UI Testing Department automates user interface testing based on vulnerabilities detected by the Vulnerability Detection Department. Specifically, the UI Testing Department automates user interface testing, reducing manual effort. For example, the UI Testing Department automatically tests button clicks and form inputs. The UI Testing Department can automate user interface testing using generative AI. The generative AI takes user interface operations as input and outputs test results. The generative AI learns user interface operation patterns and generates efficient test scenarios. For example, the generative AI learns typical user operation sequences and generates test scenarios based on them. The generative AI can also generate test scenarios that consider abnormal operations and edge cases. This allows the UI Testing Department to improve the quality of the user interface and enhance the user experience. Furthermore, the UI Testing Department automatically reports test results and provides feedback to developers. For example, the UI Testing Department reports the success rate of tests and details of failed test cases, helping developers quickly identify and fix problems. This allows the UI testing department to streamline the user interface testing process and support developers in delivering high-quality software.

[0076] The static analysis unit can analyze source code and detect unnecessary processing and inefficient parts. For example, the static analysis unit can analyze source code and detect redundant loops and the use of unnecessary variables. For example, the static analysis unit can detect redundant loops and suggest replacing them with more efficient loops. The static analysis unit can also detect computationally intensive algorithms and redundant code. For example, the static analysis unit can detect computationally intensive algorithms and suggest replacing them with more efficient algorithms. The static analysis unit can also detect redundant code and suggest replacing it with more concise code. By detecting unnecessary processing and inefficient parts of the source code, the quality of the code is improved and efficient development becomes possible. Some or all of the above processing in the static analysis unit may be performed using a generative AI, or it may be performed without a generative AI. For example, the static analysis unit can input source code into a generative AI and have the generative AI perform the detection of unnecessary processing and inefficient parts.

[0077] The test generation unit can create test cases and generate test programs based on the specifications. For example, the test generation unit can create test cases based on input data and expected output data based on the specifications, and generate test programs based on those test cases. For example, the test generation unit can create test cases and generate test programs based on the functional requirements described in the specifications. The test generation unit can also create test cases and generate test programs based on the non-functional requirements described in the specifications. For example, the test generation unit can create load test cases and generate test programs based on performance requirements. The test generation unit can also create security test cases and generate test programs based on security requirements. By creating test cases and generating test programs based on the specifications, the efficiency of testing is improved and the burden on developers is reduced. Some or all of the above-described processes in the test generation unit may be performed using a generation AI, or they may be performed without a generation AI. For example, the test generation unit can input the specifications into a generation AI and have the generation AI execute the generation of test cases and test programs.

[0078] The documentation generation unit can automatically generate relationship diagrams and transition diagrams in response to changes and additions to the source code, thereby creating development documentation. For example, the documentation generation unit can automatically generate class diagrams and sequence diagrams in response to changes and additions to the source code. For example, the documentation generation unit can automatically generate a class diagram based on changes to the source code, highlighting the changes. The documentation generation unit can also automatically generate a sequence diagram based on additions to the source code, and can add new sequences. For example, the documentation generation unit can generate a class diagram that highlights the changes by referring to the source code change history. The documentation generation unit can also generate a sequence diagram that adds new sequences by referring to the source code addition history. As a result, by automatically generating relationship diagrams and transition diagrams in response to changes and additions to the source code, and creating development documentation, the effort required for documentation creation is reduced, and the development process is made more efficient. Some or all of the above-described processes in the documentation generation unit may be performed using a generation AI, or they may be performed without using a generation AI. For example, the documentation generation unit can input changes and additions to the source code into the generation AI, and have the generation AI execute the generation of relationship diagrams and transition diagrams.

[0079] The vulnerability detection unit can detect vulnerabilities in the source code and suggest countermeasures. For example, the vulnerability detection unit can detect vulnerabilities such as SQL injection and cross-site scripting in the source code and suggest countermeasures. For example, the vulnerability detection unit can detect an SQL injection vulnerability and suggest the use of parameterized queries. The vulnerability detection unit can also detect a cross-site scripting vulnerability and suggest escaping the input data. For example, the vulnerability detection unit can detect vulnerabilities in the source code and suggest specific code modifications. The vulnerability detection unit can also suggest applying security patches. This improves security by detecting vulnerabilities in the source code and suggesting countermeasures. Some or all of the above processing in the vulnerability detection unit may be performed using a generative AI, or it may be performed without a generative AI. For example, the vulnerability detection unit can input the source code into a generative AI and have the generative AI perform vulnerability detection and suggest countermeasures.

[0080] The UI testing unit can automate user interface testing, reducing manual effort. For example, the UI testing unit can automatically test button clicks and form inputs in the user interface. For instance, it can automatically test button clicks to verify correct operation. It can also automatically test form input to verify that input data is processed correctly. Furthermore, it can automatically test screen transitions in the user interface to verify correct transitions. Finally, it can automatically test the content displayed in the user interface to verify that it is displayed correctly. This automates user interface testing and reduces manual effort, improving the efficiency of UI testing and reducing the burden on developers. Some or all of the above-described processes in the UI testing unit may be performed using or without a generative AI. For example, the UI testing unit can input user interface operations into a generative AI and have the generative AI generate the test results.

[0081] The static analysis unit can estimate the user's emotions and adjust the presentation method of the analysis results based on the estimated emotions. For example, if the user is stressed, the static analysis unit will summarize the analysis results concisely and present them in a visually easy-to-understand format. For example, if the user is stressed, the static analysis unit will visually present the analysis results using graphs and charts. Furthermore, if the user is relaxed, the static analysis unit can provide detailed analysis results to facilitate deeper understanding. For example, if the user is relaxed, the static analysis unit will provide the analysis results in a detailed text report. Also, if the user is in a hurry, the static analysis unit can highlight only the important points to facilitate quick understanding. For example, if the user is in a hurry, the static analysis unit will present the key points of the analysis results in bullet points. This allows the presentation method of the analysis results to be adjusted according to the user's emotions, providing the results in a format that is easy for the user to understand. Emotion estimation is achieved using an emotion estimation function, such as an emotion engine or generative AI. Generative AI includes, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above-described processes in the static analysis unit may be performed using a generative AI, or they may be performed without a generative AI. For example, the static analysis unit can input user emotion data into a generative AI and have the generative AI adjust the method of presenting the analysis results.

[0082] The static analysis unit can analyze the change history of source code and identify inefficient parts created by specific developers. For example, the static analysis unit can analyze parts that a specific developer has frequently modified and identify inefficient code patterns. For example, the static analysis unit can analyze parts that a specific developer has frequently modified and identify redundant code or computationally intensive algorithms. The static analysis unit can also evaluate the quality of code created by a specific developer based on the change history and suggest areas for improvement. For example, the static analysis unit can evaluate the quality of code created by a specific developer and suggest specific areas for improvement. The static analysis unit can also analyze the change history and identify inefficiencies in the entire project in which a specific developer was involved. For example, the static analysis unit can identify inefficiencies in the entire project in which a specific developer was involved and suggest areas for improvement. In this way, by analyzing the change history of source code and identifying inefficient parts created by specific developers, areas for improvement by the developers are clarified, and the quality of the code is improved. Some or all of the above processing in the static analysis unit may be performed using generative AI, or it may be performed without using generative AI. For example, the static analysis unit can input the source code change history into the generation AI and have the generation AI identify inefficient parts.

[0083] The static analysis unit can evaluate the complexity of the source code and perform detailed analysis on particularly complex parts. For example, the static analysis unit can evaluate the complexity of the source code using metrics and identify particularly complex parts. For example, the static analysis unit can evaluate the cyclomatic complexity of the source code and identify particularly complex parts. The static analysis unit can also perform detailed analysis on complex parts and suggest specific areas for improvement. For example, the static analysis unit can collect detailed debugging information on complex parts and suggest specific areas for improvement. The static analysis unit can also visually highlight highly complex parts to draw the developer's attention. For example, the static analysis unit can color-code highly complex parts to draw the developer's attention. In this way, by evaluating the complexity of the source code and performing detailed analysis on particularly complex parts, specific areas for improvement can be suggested, thereby improving the quality of the code. Some or all of the above processes in the static analysis unit may be performed using a generative AI, or they may be performed without a generative AI. For example, the static analysis unit can input the complexity of the source code into a generative AI and have the generative AI perform the identification of particularly complex parts and detailed analysis.

[0084] The static analysis unit can estimate the user's emotions and determine the priority of analysis based on the estimated emotions. For example, if the user is stressed, the static analysis unit will prioritize presenting the most important analysis results. For example, if the user is relaxed, the static analysis unit will prioritize presenting the most important analysis results. For example, if the user is relaxed, the static analysis unit will present the overall analysis results in a balanced manner. For example, if the user is in a hurry, the static analysis unit will quickly present only the most important analysis results. For example, if the user is in a hurry, the static analysis unit will quickly present only the most important analysis results. In this way, by determining the priority of analysis according to the user's emotions, the system can prioritize providing analysis results that are important to the user. Emotion estimation is achieved using an emotion estimation function, such as an emotion engine or generative AI. Generative AI includes, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above-described processes in the static analysis unit may be performed using a generative AI, or they may be performed without a generative AI. For example, the static analysis unit can input user emotion data into a generative AI and have the generative AI determine the priority of the analysis.

[0085] The static analysis unit can adjust the depth of its analysis when analyzing source code, taking into account the progress of the development project. For example, in the early stages of a project, the static analysis unit can perform an analysis that emphasizes overall code quality. For example, in the early stages of a project, the static analysis unit can evaluate the overall code quality and suggest areas for improvement. In the middle stages of a project, the static analysis unit can also perform a detailed analysis focusing on specific functions. For example, in the middle stages of a project, the static analysis unit can perform a detailed analysis focusing on specific functions and suggest specific areas for improvement. Furthermore, in the final stages of a project, the static analysis unit can perform a rigorous analysis for final quality assurance. For example, in the final stages of a project, the static analysis unit can perform a rigorous analysis for final quality assurance and suggest final areas for improvement. This allows for appropriate analysis at each stage of the project by adjusting the depth of the analysis in consideration of the progress of the development project. Some or all of the above-described processes in the static analysis unit may be performed using a generative AI, or they may be performed without a generative AI. For example, the static analysis unit can input the progress of the development project into the generative AI and have the generative AI adjust the depth of the analysis.

[0086] The static analysis unit can identify inefficient parts of source code by comparing it with codebases from other projects. For example, it can identify common inefficient patterns by comparing it with codebases from other projects. For example, it can identify redundant code or computationally intensive algorithms by comparing it with codebases from other projects. The static analysis unit can also improve inefficient parts by referring to best practices from other projects. For example, it can replace inefficient parts with more efficient code by referring to best practices from other projects. The static analysis unit can also visually highlight specific inefficient parts by comparing them with codebases from other projects. For example, it can color-code specific inefficient parts when comparing them with codebases from other projects. This allows for the identification of inefficient parts by comparing them with codebases from other projects, thereby improving common inefficient patterns and enhancing code quality. Some or all of the above processes in the static analysis unit may be performed using or without a generative AI. For example, the static analysis unit can input codebases from other projects into a generative AI and have the generative AI identify inefficient parts.

[0087] The test generation unit can estimate the user's emotions and adjust the method of generating test cases based on the estimated emotions. For example, if the user is stressed, the test generation unit will prioritize generating simple test cases. For example, if the user is stressed, the test generation unit will generate simple test cases to enable quick execution. The test generation unit can also generate detailed test cases if the user is relaxed. For example, if the user is relaxed, the test generation unit will generate detailed test cases to promote deeper understanding. The test generation unit can also quickly generate only the important test cases if the user is in a hurry. For example, if the user is in a hurry, the test generation unit will quickly generate only the important test cases to enable quick execution. In this way, by adjusting the method of generating test cases according to the user's emotions, appropriate test cases can be provided to the user. Emotion estimation is achieved using emotion estimation functions, such as emotion engines or generative AI. Generative AI includes, but is not limited to, text generation AI (e.g., LLM) and multimodal generation AI. Some or all of the above-described processes in the test generation unit may be performed using a generation AI, or they may be performed without a generation AI. For example, the test generation unit can input user emotion data into the generation AI and have the generation AI adjust the method for generating test cases.

[0088] The test generation unit can create test cases that reproduce specific bugs by referring to past bug history when generating test cases. For example, the test generation unit generates test cases that reproduce specific bugs based on past bug history. For example, the test generation unit generates test cases that reproduce specific bugs based on past bug history to prevent recurrence. The test generation unit can also analyze bug history and prioritize the generation of test cases for bugs that are likely to recur. For example, the test generation unit analyzes bug history and prioritizes the generation of test cases for bugs that are likely to recur. The test generation unit can also refer to bug history to generate detailed test cases for specific bugs. For example, the test generation unit refers to bug history to generate detailed test cases for specific bugs to prevent recurrence. In this way, by creating test cases that reproduce specific bugs by referring to past bug history, testing for bugs that are likely to recur is strengthened and quality is improved. Some or all of the above processes in the test generation unit may be performed using generation AI, or they may be performed without using generation AI. For example, the test generation unit can input past bug history into the generation AI and have the AI ​​generate test cases that reproduce a specific bug.

[0089] The test generation unit can determine which parts of the code to focus on testing based on the code changes when generating test cases. For example, the test generation unit can identify the code changes and prioritize generating test cases for those parts. For example, the test generation unit can identify the code changes, prioritize generating test cases for those parts, and verify the impact of the changes. The test generation unit can also analyze the scope of impact of the changes and generate test cases for the relevant parts. For example, the test generation unit can analyze the scope of impact of the changes and generate test cases for the relevant parts. The test generation unit can also determine the priority of test cases based on the importance of the changes. For example, the test generation unit determines the priority of test cases based on the importance of the changes and prioritizes testing the important parts. This allows for effective testing that takes into account the impact of the changes by determining which parts of the code to focus on testing based on the code changes. Some or all of the above processes in the test generation unit may be performed using a generation AI, or they may be performed without using a generation AI. For example, the test generation unit can input code changes into the generation AI and have the AI ​​determine which parts to focus on when testing.

[0090] The test generation unit can estimate the user's emotions and prioritize test cases based on the estimated emotions. For example, if the user is stressed, the test generation unit will prioritize executing important test cases and provide results quickly. Alternatively, if the user is relaxed, the test generation unit can execute a balanced set of test cases and provide detailed results. Furthermore, if the user is in a hurry, the test generation unit can quickly execute only the most important test cases and provide results quickly. This allows for prioritizing test cases based on the user's emotions, ensuring that test cases important to the user are executed first. Emotion estimation is achieved using emotion estimation capabilities, such as an emotion engine or generative AI. Generative AI includes, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above-described processes in the test generation unit may be performed using a generation AI, or they may be performed without a generation AI. For example, the test generation unit can input user emotion data into a generation AI and have the generation AI determine the priority of test cases.

[0091] The test generation unit can adjust the difficulty of test cases when generating them, taking into account the developer's skill level. For example, the test generation unit can generate a balanced mix of easy and difficult test cases according to the developer's skill level. For instance, it can prioritize generating easy-to-understand test cases for developers with lower skill levels. It can also generate detailed and complex test cases for developers with higher skill levels. For example, it can generate detailed and complex test cases for developers with higher skill levels to promote deeper understanding. By adjusting the difficulty of test cases to account for the developer's skill level, the test generation unit can provide appropriate test cases for developers. Some or all of the above processing in the test generation unit may be performed using a generation AI, or it may be performed without a generation AI. For example, the test generation unit can input the developer's skill level into the generation AI and have the generation AI adjust the difficulty of the test cases.

[0092] The test generation unit can create new test cases by referencing test cases from other projects. For example, the test generation unit can reference test cases from other projects to generate common test cases, thereby improving testing efficiency. The test generation unit can also create new test cases by referencing best practices from other projects, thereby improving quality. Furthermore, the test generation unit can analyze test cases from other projects, improve specific test cases, and generate them, thereby improving quality. In this way, by referencing test cases from other projects, common test cases can be generated, improving testing efficiency. Some or all of the above processes in the test generation unit may be performed using a generation AI, or they may not be performed using a generation AI. For example, the test generation unit can input test cases from other projects into a generation AI and have the generation AI create new test cases.

[0093] The documentation generation unit can estimate the user's emotions and adjust the way the document is presented based on those emotions. For example, if the user is stressed, the documentation generation unit can generate a concise and visually easy-to-understand document. For example, if the user is stressed, the documentation generation unit can generate a visually easy-to-understand document using graphs and charts. The documentation generation unit can also generate a document containing detailed information if the user is relaxed. For example, if the user is relaxed, the documentation generation unit can generate a document containing a detailed text report. The documentation generation unit can also generate a document that highlights only the important points if the user is in a hurry. For example, if the user is in a hurry, the documentation generation unit can generate a document that highlights the important points in bullet points. In this way, by adjusting the way the document is presented according to the user's emotions, it is possible to provide a document that is easy for the user to understand. Emotion estimation is achieved using an emotion estimation function, such as an emotion engine or generative AI. Generative AI is, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above-described processes in the documentation generation unit may be performed using a generation AI, or they may be performed without a generation AI. For example, the documentation generation unit can input user sentiment data into the generation AI and have the generation AI adjust the way the document is presented.

[0094] The documentation generation unit can refer to the code change history and highlight changes when generating documentation. For example, the documentation generation unit generates documentation that highlights changes based on the code change history. For example, the documentation generation unit generates documentation that highlights changes using color coding based on the code change history. The documentation generation unit can also refer to the change history and generate documentation that includes detailed explanations of changes. For example, the documentation generation unit refers to the change history and generates documentation that includes detailed explanations of changes. The documentation generation unit can also visually display the change history and generate documentation that highlights changes. For example, the documentation generation unit visually displays the change history using graphs or charts and generates documentation that highlights changes. This allows developers to quickly grasp changes by referring to the code change history and highlighting the changes. Some or all of the above processes in the documentation generation unit may be performed using generation AI, or they may not be performed using generation AI. For example, the documentation generation unit can input the code change history into the generation AI and have the AI ​​generate documentation that highlights the changes.

[0095] The documentation generation unit can automatically generate documents tailored to specific development phases during document generation. For example, in the early stages of a project, the documentation generation unit can generate an overall design document, indicating the direction of the project. The documentation generation unit can also generate a detailed design document in the middle stages of a project, showing specific implementation methods. Furthermore, the documentation generation unit can generate the final release document in the final stages of a project, preparing for release. This allows for the provision of documents suitable for the development process by automatically generating documents tailored to specific development phases. Some or all of the above-described processes in the documentation generation unit may be performed using a generation AI, or they may not be performed using a generation AI. For example, the documentation generation unit can input a specific development phase into a generation AI and have the generation AI perform the automatic document generation.

[0096] The documentation generation unit can estimate the user's emotions and prioritize documents based on those emotions. For example, if the user is stressed, the documentation generation unit will prioritize generating important documents and provide them quickly. Furthermore, if the user is relaxed, the documentation generation unit can generate a balanced mix of documents, providing detailed information. Also, if the user is in a hurry, the documentation generation unit can quickly generate only the most important documents, providing them quickly. This allows for the prioritization of documents based on the user's emotions, ensuring that important documents are delivered to the user first. Emotion estimation is achieved using an emotion estimation function, such as an emotion engine or generative AI. Generative AI may include, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above-described processes in the documentation generation unit may be performed using a generation AI, or they may be performed without a generation AI. For example, the documentation generation unit can input user sentiment data into the generation AI and have the generation AI determine the priority of documents.

[0097] The documentation generation unit can generate different documents depending on the developer's role during document generation. For example, the documentation generation unit can generate technical documents for developers. For example, it can generate documents containing technical details for developers and provide them in a format that is easy for developers to understand. The documentation generation unit can also generate progress report documents for project managers. For example, it can generate documents reporting the progress for project managers and provide them in a format that makes it easy to understand the project's progress. The documentation generation unit can also generate test case documents for testers. For example, it can generate documents containing test case details for testers to support the execution of tests. In this way, by generating different documents depending on the developer's role, information appropriate to each role can be provided. Some or all of the above processes in the documentation generation unit may be performed using a generation AI, or they may not be performed using a generation AI. For example, the documentation generation unit can input the developer's role into the generation AI and have the generation AI execute the generation of different documents.

[0098] The documentation generation unit can create new documents by referencing documents from other projects during document generation. For example, the documentation generation unit can reference documents from other projects to generate common documents. For example, the documentation generation unit can reference documents from other projects to generate common documents and improve the efficiency of document creation. The documentation generation unit can also create new documents by referencing best practices from other projects. For example, the documentation generation unit can reference best practices from other projects to create new documents and improve their quality. The documentation generation unit can also analyze documents from other projects and improve specific documents before generating them. For example, the documentation generation unit can analyze documents from other projects, improve specific documents before generating them, and improve their quality. This allows for the generation of common documents by referencing documents from other projects, thereby improving the efficiency of document creation. Some or all of the above processes in the documentation generation unit may be performed using generation AI, or they may not be performed using generation AI. For example, the documentation generation unit can input documents from other projects into the generation AI and have the generation AI create new documents.

[0099] The vulnerability detection unit can estimate the user's emotions and adjust the way vulnerabilities are presented based on those emotions. For example, if the user is stressed, the vulnerability detection unit may present vulnerabilities in a concise and visually easy-to-understand format. For example, if the user is stressed, the vulnerability detection unit may present vulnerabilities in a visually easy-to-understand format using graphs and charts. Furthermore, if the user is relaxed, the vulnerability detection unit can provide detailed vulnerability information to facilitate a deeper understanding. For example, if the user is relaxed, the vulnerability detection unit may provide vulnerability information using a detailed text report. Also, if the user is in a hurry, the vulnerability detection unit can highlight only critical vulnerabilities to facilitate quick understanding. For example, if the user is in a hurry, the vulnerability detection unit may highlight critical vulnerabilities in a bulleted list. This allows vulnerabilities to be presented in a format that is easy for the user to understand by adjusting the presentation method according to the user's emotions. Emotion estimation is achieved using an emotion estimation function, such as an emotion engine or generative AI. Generative AI includes, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above-described processes in the vulnerability detection unit may be performed using a generating AI, or they may be performed without using a generating AI. For example, the vulnerability detection unit can input user emotion data into the generating AI and have the generating AI adjust the method of presenting vulnerabilities.

[0100] The vulnerability detection unit can, when detecting a vulnerability, refer to past vulnerability history to focus on detecting specific vulnerabilities. For example, the vulnerability detection unit can focus on detecting vulnerabilities that are likely to recur based on past vulnerability history. For example, the vulnerability detection unit can focus on detecting vulnerabilities that are likely to recur based on past vulnerability history to prevent recurrence. The vulnerability detection unit can also analyze vulnerability history and provide detailed detection methods for specific vulnerabilities. For example, the vulnerability detection unit can analyze vulnerability history and provide detailed detection methods for specific vulnerabilities. The vulnerability detection unit can also refer to vulnerability history to perform focused detection on specific vulnerabilities. For example, the vulnerability detection unit can refer to vulnerability history to perform focused detection on specific vulnerabilities to prevent recurrence. By referring to past vulnerability history to focus on detecting specific vulnerabilities, the detection of vulnerabilities that are likely to recur is strengthened, and security is improved. Some or all of the above processing in the vulnerability detection unit may be performed using a generation AI, or it may be performed without a generation AI. For example, the vulnerability detection unit can input past vulnerability history into a generation AI and have the generation AI execute a process to focus on detecting specific vulnerabilities.

[0101] The vulnerability detection unit can determine which parts to focus on detecting vulnerabilities based on the code changes. For example, the vulnerability detection unit can identify the code changes and prioritize vulnerability detection in those parts. For example, the vulnerability detection unit can identify the code changes, prioritize vulnerability detection in those parts, and confirm the impact of the changes. The vulnerability detection unit can also analyze the scope of impact of the changes and perform vulnerability detection in related parts. For example, the vulnerability detection unit can analyze the scope of impact of the changes and perform vulnerability detection in related parts. The vulnerability detection unit can also determine the priority of vulnerability detection based on the importance of the changes. For example, the vulnerability detection unit determines the priority of vulnerability detection based on the importance of the changes and prioritizes detection in important parts. This allows for effective vulnerability detection that takes into account the impact of the changes by determining which parts to focus on detecting based on the code changes. Some or all of the above processing in the vulnerability detection unit may be performed using generative AI, or it may be performed without using generative AI. For example, the vulnerability detection unit can input code changes into a generating AI and have the AI ​​determine which parts to focus on for detection.

[0102] The vulnerability detection unit can estimate the user's emotions and prioritize vulnerabilities based on those emotions. For example, if the user is stressed, the vulnerability detection unit will prioritize presenting critical vulnerabilities and provide quick countermeasures. Furthermore, if the user is relaxed, the vulnerability detection unit can present a balanced range of vulnerabilities and provide detailed countermeasures. Also, if the user is in a hurry, the vulnerability detection unit can quickly present only the most important vulnerabilities and provide quick countermeasures. This allows the system to prioritize vulnerabilities based on the user's emotions, thereby providing users with the most important vulnerabilities. Emotion estimation is achieved using an emotion estimation function, such as an emotion engine or generative AI. Generative AI includes, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above-described processes in the vulnerability detection unit may be performed using a generative AI, or they may be performed without using a generative AI. For example, the vulnerability detection unit can input user sentiment data into a generative AI and have the generative AI determine the priority of vulnerabilities.

[0103] The vulnerability detection unit can adjust how vulnerabilities are presented when vulnerabilities are detected, taking into account the developer's skill level. For example, the vulnerability detection unit can present vulnerabilities to developers with low skill levels in an easy-to-understand format. For example, the vulnerability detection unit can present vulnerabilities to developers with low skill levels in a visually easy-to-understand format using graphs and charts. The vulnerability detection unit can also provide detailed vulnerability information to developers with high skill levels. For example, the vulnerability detection unit can provide vulnerability information to developers with high skill levels using a detailed text report. Furthermore, the vulnerability detection unit can customize how vulnerabilities are presented according to the skill level. For example, the vulnerability detection unit can customize how vulnerabilities are presented according to the skill level and provide them in a format that is easy for developers to understand. In this way, by adjusting the method of presenting vulnerabilities to take into account the developer's skill level, vulnerabilities can be provided in a format that is easy for developers to understand. Some or all of the above processing in the vulnerability detection unit may be performed using a generative AI, or it may be performed without using a generative AI. For example, the vulnerability detection unit can input the developer's skill level into a generative AI and have the generative AI perform the adjustment of the vulnerability presentation method.

[0104] The vulnerability detection unit can detect new vulnerabilities by referring to vulnerability information from other projects when detecting vulnerabilities. For example, the vulnerability detection unit can refer to vulnerability information from other projects to detect common vulnerabilities. For example, the vulnerability detection unit can refer to vulnerability information from other projects to detect common vulnerabilities and improve security. The vulnerability detection unit can also detect new vulnerabilities by referring to best practices from other projects. For example, the vulnerability detection unit can refer to best practices from other projects to detect new vulnerabilities and improve security. The vulnerability detection unit can also analyze vulnerability information from other projects and improve specific vulnerabilities for detection. For example, the vulnerability detection unit can analyze vulnerability information from other projects, improve specific vulnerabilities for detection, and improve security. In this way, by referring to vulnerability information from other projects, common vulnerabilities can be detected and security improved. Some or all of the above processing in the vulnerability detection unit may be performed using a generative AI, or it may be performed without a generative AI. For example, the vulnerability detection unit can input vulnerability information from other projects into a generative AI and have the generative AI perform the detection of new vulnerabilities.

[0105] The UI testing unit can estimate the user's emotions and adjust the UI test execution method based on the estimated emotions. For example, if the user is stressed, the UI testing unit can prioritize simple UI tests. For example, if the user is stressed, the UI testing unit can conduct simple UI tests and provide results quickly. The UI testing unit can also conduct detailed UI tests if the user is relaxed. For example, if the user is relaxed, the UI testing unit can conduct detailed UI tests to promote deeper understanding. The UI testing unit can also quickly execute only the important UI tests if the user is in a hurry. For example, if the user is in a hurry, the UI testing unit can quickly execute only the important UI tests and provide results quickly. In this way, by adjusting the UI test execution method according to the user's emotions, appropriate UI tests can be provided to the user. Emotion estimation is achieved using emotion estimation functions, such as emotion engines or generative AI. Generative AI includes, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above processing in the UI testing unit may be performed using generative AI or not. For example, the UI testing unit can input user emotion data into a generating AI and have the AI ​​adjust the UI testing methodology.

[0106] The UI testing department can perform tests to reproduce specific bugs by referring to past UI bug history during UI testing. For example, the UI testing department can perform tests to reproduce specific bugs based on past UI bug history. For example, the UI testing department can perform tests to reproduce specific bugs based on past UI bug history to prevent recurrence. The UI testing department can also analyze bug history and prioritize testing for bugs that are prone to recurrence. For example, the UI testing department analyzes bug history and prioritizes testing for bugs that are prone to recurrence. The UI testing department can also perform detailed tests for specific bugs by referring to bug history. For example, the UI testing department can perform detailed tests for specific bugs by referring to bug history to prevent recurrence. In this way, by performing tests to reproduce specific bugs by referring to past UI bug history, testing for bugs that are prone to recurrence is strengthened and quality is improved. Some or all of the above processes in the UI testing department may be performed using a generative AI, or not. For example, the UI testing department can input past UI bug history into a generative AI and have the generative AI execute tests to reproduce specific bugs.

[0107] The UI testing unit can determine which parts to focus on testing by referring to the user's operation history during UI testing. For example, the UI testing unit can focus on testing frequently used parts based on the user's operation history. For example, the UI testing unit can focus on testing frequently used parts based on the user's operation history to improve the quality of those parts. The UI testing unit can also analyze the operation history and prioritize testing of important operations. For example, the UI testing unit can analyze the operation history and prioritize testing of important operations. The UI testing unit can also refer to the operation history to conduct detailed testing of specific operations. For example, the UI testing unit can refer to the operation history to conduct detailed testing of specific operations to improve quality. In this way, by determining which parts to focus on testing by referring to the user's operation history, testing of frequently used parts is strengthened and quality is improved. Some or all of the above processes in the UI testing unit may be performed using generative AI, or not. For example, the UI testing unit can input the user's operation history into generative AI and have the generative AI determine which parts to focus on testing.

[0108] The UI testing department can estimate user emotions and prioritize UI tests based on those emotions. For example, if a user is stressed, the UI testing department will prioritize important UI tests and provide results quickly. If a user is relaxed, the UI testing department can also conduct a balanced overall UI test and provide detailed results. If a user is in a hurry, the UI testing department can quickly conduct only the most important UI tests and provide results quickly. This allows for prioritizing UI tests according to user emotions, ensuring that important UI tests are prioritized for the user. Emotion estimation is achieved using emotion estimation functions, such as emotion engines or generative AI. Generative AI includes, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above-described processes in the UI testing unit may be performed using a generative AI, or they may not be performed using a generative AI. For example, the UI testing unit can input user sentiment data into a generative AI and have the generative AI determine the priority of UI tests.

[0109] The UI testing unit can adjust its testing methods when conducting UI tests, taking into account the user's device information. For example, if the user is using a smartphone, the UI testing unit can conduct tests tailored to the screen size to confirm the user experience on a smartphone. Similarly, if the user is using a tablet, the UI testing unit can conduct tests optimized for larger screens to confirm the user experience on a tablet. Furthermore, if the user is using a smartwatch, the UI testing unit can conduct concise and highly visible tests to confirm the user experience on a smartwatch. This allows the UI testing unit to provide UI tests optimized for each device by adjusting the testing methods based on the user's device information. Some or all of the above-described processes in the UI testing unit may be performed using or without a generative AI. For example, the UI testing unit can input the user's device information into a generative AI and have the generative AI adjust the testing methods.

[0110] The UI testing department can create new test cases by referencing UI test cases from other projects during UI testing. For example, the UI testing department can refer to UI test cases from other projects to generate common test cases, thereby improving testing efficiency. The UI testing department can also create new UI test cases by referencing best practices from other projects, thereby improving quality. Furthermore, the UI testing department can analyze UI test cases from other projects, improve specific test cases, and generate them, thereby improving quality. In this way, by referencing UI test cases from other projects, common test cases can be generated, improving testing efficiency. Some or all of the above processes in the UI testing department may be performed using a generation AI, or not. For example, the UI testing department can input UI test cases from other projects into a generation AI and have the generation AI create new test cases.

[0111] The system according to the embodiment is not limited to the example described above, and various modifications are possible, for example, as follows.

[0112] The integrated platform can further incorporate the ability to estimate the user's emotions and adjust the entire development process based on those emotions. For example, if the user is stressed, the platform can automatically adjust task priorities, prioritizing high-priority tasks. If the user is relaxed, it can also provide detailed feedback and additional learning resources. Furthermore, if the user is in a hurry, it can quickly provide only the most important information to support efficient work. This reduces user stress and provides an efficient work environment by adjusting the entire development process according to the user's emotions. Emotion estimation is achieved using emotion estimation functions, such as an emotion engine or generative AI. Generative AI includes, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above processing in the integrated platform may be performed using generative AI or not. For example, the integrated platform can input user emotion data into a generative AI and have the generative AI perform the adjustments to the development process.

[0113] The integrated platform can further include features to assess developers' skill levels and provide support tailored to those skill levels. For example, it can provide novice developers with basic coding guidelines and simple tasks to support their skill development. It can also provide experienced developers with complex problem-solving and advanced technical advice. Furthermore, it can suggest appropriate learning resources and training programs based on the developer's skill level. This promotes efficient learning and growth by providing support tailored to the developer's skill level, improving the overall quality of the development process. Skill level assessment may or may not be performed using generative AI. For example, the integrated platform can input developer skill data into a generative AI, allowing the AI ​​to perform skill level assessment and provide support.

[0114] The integrated platform can also include the ability to monitor the progress of development projects in real time and provide feedback based on progress. For example, if a project is behind schedule, the platform can identify the cause of the delay and suggest solutions. If progress is on track, it can also provide advice and resources for moving to the next step. Furthermore, it can provide tools to facilitate communication among team members and strengthen collaboration, depending on the project's progress. This supports project success and enables efficient development by monitoring the progress of development projects in real time and providing appropriate feedback. Progress monitoring may or may not be performed using generative AI. For example, the integrated platform can input project progress data into a generative AI and have the generative AI provide feedback.

[0115] The integrated platform can further incorporate features to optimize the developer's work environment. For example, it can analyze the developer's work patterns and suggest optimal work and break times. It can also adjust physical elements of the work environment, such as temperature and lighting, to provide a comfortable working environment. Furthermore, it can provide music or white noise to enhance the developer's concentration. By optimizing the developer's work environment, it supports efficient work and improves the overall quality of the development process. This optimization of the work environment may or may not be performed using generative AI. For example, the integrated platform can input developer work data into a generative AI and have the generative AI perform the optimization of the work environment.

[0116] The integrated platform can also include the ability to estimate the developer's emotions and adjust the communication method based on those emotions. For example, if the user is stressed, the platform can provide concise and clear messages to avoid misunderstandings. If the user is relaxed, it can also provide detailed explanations and additional information. Furthermore, if the user is in a hurry, it can quickly provide only the most important information to support efficient communication. This allows for effective information transfer and improves the overall efficiency of the development process by adjusting the communication method according to the user's emotions. Emotion estimation is achieved using emotion estimation functions, such as an emotion engine or generative AI. Generative AI includes, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above processing in the integrated platform may be performed using generative AI or not. For example, the integrated platform can input user emotion data into a generative AI and have the generative AI adjust the communication method.

[0117] The integrated platform can also include features to monitor the developer's health and provide support tailored to their health status. For example, it can monitor the developer's heart rate and stress level, and suggest a break if their health deteriorates. If their health is good, it can also provide tasks to improve their concentration. Furthermore, it can provide advice on appropriate exercise and relaxation based on the developer's health status. This allows for a healthier work environment and improves the overall efficiency of the development process by monitoring the developer's health and providing appropriate support. Health monitoring may be performed using generative AI or not. For example, the integrated platform can input the developer's health data into a generative AI and have the generative AI provide support.

[0118] The integrated platform can also include the ability to estimate the developer's emotions and adjust the content of feedback based on those emotions. For example, if a user is stressed, the platform can prioritize providing positive feedback to boost their motivation. If the user is relaxed, it can also provide detailed suggestions for improvement and constructive feedback. Furthermore, if the user is in a hurry, it can quickly provide only the most important feedback to support efficient improvement. This ensures effective feedback and improves the overall quality of the development process by adjusting the content of feedback according to the user's emotions. Emotion estimation is achieved using emotion estimation functions, such as an emotion engine or generative AI. Generative AI includes, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above processing in the integrated platform may be performed using generative AI or not. For example, the integrated platform can input user emotion data into a generative AI and have the generative AI adjust the content of the feedback.

[0119] The integrated platform can further incorporate the ability to analyze developers' work history and suggest efficient work patterns. For example, it can suggest the most efficient work times and task sequences based on past work history. It can also analyze work history to identify frequently occurring problems and bottlenecks and suggest solutions. Furthermore, it can suggest resources and training programs that help improve developers' skills based on their work history. By analyzing developers' work history and suggesting efficient work patterns, it improves work efficiency and the overall quality of the development process. The analysis of work history may be performed using generative AI or not. For example, the integrated platform can input work history data into a generative AI and have the generative AI suggest efficient work patterns.

[0120] The integrated platform can further include the ability to estimate the developer's emotions and adjust task assignments based on those emotions. For example, if a user is stressed, the platform can prioritize assigning easy tasks to reduce their burden. Conversely, if the user is relaxed, it can assign more complex or challenging tasks. Furthermore, if the user is in a hurry, it can quickly assign only the most important tasks to support efficient work. This allows for effective task management and improves the overall efficiency of the development process by adjusting task assignments according to the user's emotions. Emotion estimation is achieved using emotion estimation functions, such as an emotion engine or generative AI. Generative AI includes, but is not limited to, text generation AI (e.g., LLM) or multimodal generation AI. Some or all of the above processing in the integrated platform may be performed using generative AI or not. For example, the integrated platform can input user emotion data into a generative AI and have the generative AI perform the task assignment adjustments.

[0121] The integrated platform can also include features to provide guidelines to further improve developers' work efficiency. For example, it can suggest efficient coding styles and best practices to support developers in working efficiently. It can also provide tools and resources to improve work efficiency. Furthermore, it can monitor developers' work efficiency and provide feedback on areas for improvement. In this way, by providing guidelines to improve developers' work efficiency, it supports efficient work and improves the quality of the entire development process. The provision of guidelines may or may not be done using generative AI. For example, the integrated platform can input work efficiency data into a generative AI and have the generative AI provide the guidelines.

[0122] The following briefly describes the processing flow for example form 2.

[0123] Step 1: The static analysis unit performs static analysis of the source code to detect unnecessary processing and inefficient parts. For example, it detects redundant loops, the use of unnecessary variables, computationally intensive algorithms, and redundant code. Source code analysis can also be performed using generative AI. Step 2: The test generation unit automatically generates test programs based on the unnecessary processing and inefficient parts detected by the static analysis unit. For example, it creates test cases based on the specifications and generates test programs based on input data and expected output data. Test programs can also be generated using generation AI. Step 3: The documentation generation unit automatically generates relationship diagrams and transition diagrams based on the test programs generated by the test generation unit. For example, it automatically generates class diagrams and sequence diagrams in response to changes or additions to the source code, creating development documentation. It is also possible to generate relationship diagrams and transition diagrams using generation AI. Step 4: The vulnerability detection unit detects vulnerabilities based on the documentation generated by the documentation generation unit and proposes countermeasures. For example, it detects vulnerabilities such as SQL injection and cross-site scripting and proposes countermeasures. It is also possible to use generation AI to detect vulnerabilities and propose countermeasures. Step 5: The UI testing unit automates user interface testing based on vulnerabilities detected by the vulnerability detection unit. For example, it automates button clicks and form inputs, reducing manual effort. User interface testing can also be automated using generative AI.

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

[0125] Data generation model 58 is a form of so-called generative AI (Artificial Intelligence). An example of data generation model 58 is ChatGPT (registered trademark) (Internet search).<URL: https: / / openai.com / blog / chatgpt> Examples of generative AI include text generation AI, image generation AI, and multimodal generation AI. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images (e.g., still image data or video data). The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference result in one or more data formats from audio data, text data, and image data. The data generation model 58 includes, for example, text generation AI, image generation AI, and multimodal generation AI. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization. The specific processing unit 290 performs the specific processing described above using the data generation model 58. The data generation model 58 may be a fine-tuned model that outputs inference results from prompts that do not contain instructions, in which case the data generation model 58 can output inference results from prompts that do not contain instructions. In the data processing device 12, etc., there are multiple types of data generation models 58, and the data generation model 58 includes AI other than generative AI. AI other than generative AI includes, for example, linear regression, logistic regression, decision trees, random forests, support vector machines (SVMs), k-means clustering, convolutional neural networks (CNNs), recurrent neural networks (RNNs), generative adversarial networks (GANs), or naive Bayes, and can perform various processes, but is not limited to these examples. Also, the AI ​​may be an AI agent. Furthermore, when the processing of each of the above parts is performed by the AI, the processing may be performed by the AI ​​in part or in whole, but is not limited to this example.Furthermore, processing performed by AI, including generative AI, may be replaced with rule-based processing, and rule-based processing may be replaced with processing performed by AI, including generative AI.

[0126] Furthermore, the processing performed by the data processing system 10 described above is carried out by the specific processing unit 290 of the data processing device 12 or the control unit 46A of the smart device 14, but it may also be carried out by the specific processing unit 290 of the data processing device 12 and the control unit 46A of the smart device 14. In addition, the specific processing unit 290 of the data processing device 12 acquires or collects information necessary for processing from the smart device 14 or an external device, and the smart device 14 acquires or collects information necessary for processing from the data processing device 12 or an external device.

[0127] Each of the multiple elements described above, including the static analysis unit, test generation unit, documentation generation unit, vulnerability detection unit, and UI testing unit, is implemented in at least one of the smart device 14 and the data processing unit 12. For example, the static analysis unit is implemented by the processor 46 of the smart device 14 or the specific processing unit 290 of the data processing unit 12. The test generation unit is implemented by the specific processing unit 290 of the data processing unit 12, for example, and creates test cases and generates test programs based on specifications. The documentation generation unit is implemented by the control unit 46A of the smart device 14 or the specific processing unit 290 of the data processing unit 12, for example, and automatically generates relationship diagrams and transition diagrams. The vulnerability detection unit is implemented by the specific processing unit 290 of the data processing unit 12, for example, and detects vulnerabilities in the source code and suggests countermeasures. The UI testing unit is implemented by the control unit 46A of the smart device 14 or the specific processing unit 290 of the data processing unit 12, for example, and automates user interface testing. The correspondence between each part and the device or control unit is not limited to the examples described above, and various modifications are possible.

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

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

[0130] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN and / or LAN.

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

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

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

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

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

[0136] The processor 28 reads a 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 acting as a specific processing unit 290 according to the specific processing program 56 executed on the RAM 30.

[0137] Storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290. The identification processing unit 290 can estimate the user's emotions using the emotion identification model 59 and perform identification processing using the user's emotions. The emotion estimation function (emotion identification function) using the emotion identification model 59 performs various estimations and predictions regarding the user's emotions, including but not limited to these examples. Furthermore, emotion estimation and prediction also include, for example, emotion analysis.

[0138] In the smart glasses 214, specific processing is performed by the processor 46. The storage 50 stores a specific processing program 60. The processor 46 reads the specific processing program 60 from the storage 50 and executes the read specific processing program 60 on the RAM 48. The specific processing is realized by the processor 46 acting as a control unit 46A according to the specific processing program 60 executed on the RAM 48. The smart glasses 214 also have a data generation model 58 and an emotion identification model 59, similar to the data generation model and emotion identification model 59, and can perform processing similar to that of the specific processing unit 290 using these models.

[0139] Furthermore, other devices besides the data processing device 12 may also have the data generation model 58. For example, a server device may have the data generation model 58. In this case, the data processing device 12 obtains processing results (such as prediction results) using the data generation model 58 by communicating with the server device that has the data generation model 58. Also, the data processing device 12 may be a server device or a terminal device owned by the user (for example, a mobile phone, robot, home appliance, etc.).

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

[0141] The data generation model 58 is a so-called generative AI. An example of a data generation model 58 is a generative AI such as ChatGPT. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and inference data such as audio data representing speech, text data representing text, and image data representing images (e.g., still image data or video data). The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference result in one or more data formats such as audio data, text data, and image data. The data generation model 58 includes, for example, text generation AI, image generation AI, and multimodal generation AI. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization. The specific processing unit 290 performs the specific processing described above using the data generation model 58. The data generation model 58 may be a fine-tuned model that outputs inference results from prompts that do not contain instructions, in which case the data generation model 58 can output inference results from prompts that do not contain instructions. In the data processing device 12, etc., there are multiple types of data generation models 58, and the data generation model 58 includes AI other than generative AI. AI other than generative AI includes, for example, linear regression, logistic regression, decision trees, random forests, support vector machines (SVM), k-means clustering, convolutional neural networks (CNN), recurrent neural networks (RNN), generative adversarial networks (GAN), or naive Bayes, and can perform various processes, but is not limited to these examples. Also, the AI ​​may be an AI agent. Furthermore, when the processing of each part described above is performed by the AI, the processing may be performed by the AI ​​in part or in whole, but is not limited to this example. Also, processing performed by an AI including a generative AI may be replaced by rule-based processing, and rule-based processing may be replaced by processing performed by an AI including a generative AI.

[0142] The data processing system 210 according to the second embodiment performs the same processing as the data processing system 10 according to the first embodiment. The processing by the data processing system 210 is performed by the specific processing unit 290 of the data processing device 12 or the control unit 46A of the smart glasses 214, but it may also be performed by the specific processing unit 290 of the data processing device 12 and the control unit 46A of the smart glasses 214. In addition, the specific processing unit 290 of the data processing device 12 acquires or collects information necessary for processing from the smart glasses 214 or an external device, and the smart glasses 214 acquires or collects information necessary for processing from the data processing device 12 or an external device.

[0143] Each of the multiple elements described above, including the static analysis unit, test generation unit, documentation generation unit, vulnerability detection unit, and UI testing unit, is implemented in at least one of the smart glasses 214 and the data processing unit 12. For example, the static analysis unit is implemented by the processor 46 of the smart glasses 214 or the specific processing unit 290 of the data processing unit 12. The test generation unit is implemented by the specific processing unit 290 of the data processing unit 12, for example, and creates test cases and generates test programs based on specifications. The documentation generation unit is implemented by the control unit 46A of the smart glasses 214 or the specific processing unit 290 of the data processing unit 12, for example, and automatically generates relationship diagrams and transition diagrams. The vulnerability detection unit is implemented by the specific processing unit 290 of the data processing unit 12, for example, and detects vulnerabilities in the source code and suggests countermeasures. The UI testing unit is implemented by the control unit 46A of the smart glasses 214 or the specific processing unit 290 of the data processing unit 12, for example, and automates user interface testing. The correspondence between each part and the device or control unit is not limited to the examples described above, and various modifications are possible.

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

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

[0146] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN and / or LAN.

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

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

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

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

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

[0152] The processor 28 reads a 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 acting as a specific processing unit 290 according to the specific processing program 56 executed on the RAM 30.

[0153] Storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290. The identification processing unit 290 can estimate the user's emotions using the emotion identification model 59 and perform identification processing using the user's emotions. The emotion estimation function (emotion identification function) using the emotion identification model 59 performs various estimations and predictions regarding the user's emotions, including but not limited to these examples. Furthermore, emotion estimation and prediction also include, for example, emotion analysis.

[0154] In the headset terminal 314, specific processing is performed by the processor 46. The storage 50 stores a specific program 60. The processor 46 reads the specific program 60 from the storage 50 and executes the read specific program 60 on the RAM 48. The specific processing is realized by the processor 46 acting as a control unit 46A according to the specific program 60 executed on the RAM 48. The headset terminal 314 also has a data generation model 58 and an emotion identification model 59, similar to the data generation model and emotion identification model 59, and can perform processing similar to that of the specific processing unit 290 using these models.

[0155] Furthermore, other devices besides the data processing device 12 may also have the data generation model 58. For example, a server device may have the data generation model 58. In this case, the data processing device 12 obtains processing results (such as prediction results) using the data generation model 58 by communicating with the server device that has the data generation model 58. Also, the data processing device 12 may be a server device or a terminal device owned by the user (for example, a mobile phone, robot, home appliance, etc.).

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

[0157] The data generation model 58 is a so-called generative AI. An example of a data generation model 58 is a generative AI such as ChatGPT. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and inference data such as audio data representing speech, text data representing text, and image data representing images (e.g., still image data or video data). The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference result in one or more data formats such as audio data, text data, and image data. The data generation model 58 includes, for example, text generation AI, image generation AI, and multimodal generation AI. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization. The specific processing unit 290 performs the specific processing described above using the data generation model 58. The data generation model 58 may be a fine-tuned model that outputs inference results from prompts that do not contain instructions, in which case the data generation model 58 can output inference results from prompts that do not contain instructions. In the data processing device 12, etc., there are multiple types of data generation models 58, and the data generation model 58 includes AI other than generative AI. AI other than generative AI includes, for example, linear regression, logistic regression, decision trees, random forests, support vector machines (SVM), k-means clustering, convolutional neural networks (CNN), recurrent neural networks (RNN), generative adversarial networks (GAN), or naive Bayes, and can perform various processes, but is not limited to these examples. Also, the AI ​​may be an AI agent. Furthermore, when the processing of each part described above is performed by the AI, the processing may be performed by the AI ​​in part or in whole, but is not limited to this example. Also, processing performed by an AI including a generative AI may be replaced by rule-based processing, and rule-based processing may be replaced by processing performed by an AI including a generative AI.

[0158] The data processing system 310 according to the third embodiment performs the same processing as the data processing system 10 according to the first embodiment. The processing by the data processing system 310 is performed by the specific processing unit 290 of the data processing device 12 or the control unit 46A of the headset terminal 314, but may also be performed by the specific processing unit 290 of the data processing device 12 and the control unit 46A of the headset terminal 314. In addition, the specific processing unit 290 of the data processing device 12 acquires or collects information necessary for processing from the headset terminal 314 or an external device, and the headset terminal 314 acquires or collects information necessary for processing from the data processing device 12 or an external device.

[0159] Each of the multiple elements described above, including the static analysis unit, test generation unit, documentation generation unit, vulnerability detection unit, and UI testing unit, is implemented in at least one of the headset terminal 314 and the data processing unit 12. For example, the static analysis unit is implemented by the processor 46 of the headset terminal 314 or the specific processing unit 290 of the data processing unit 12. The test generation unit is implemented by the specific processing unit 290 of the data processing unit 12, for example, and creates test cases and generates test programs based on specifications. The documentation generation unit is implemented by the control unit 46A of the headset terminal 314 or the specific processing unit 290 of the data processing unit 12, for example, and automatically generates relationship diagrams and transition diagrams. The vulnerability detection unit is implemented by the specific processing unit 290 of the data processing unit 12, for example, and detects vulnerabilities in the source code and suggests countermeasures. The UI testing unit is implemented by the control unit 46A of the headset terminal 314 or the specific processing unit 290 of the data processing unit 12, for example, and automates user interface testing. The correspondence between each part and the device or control unit is not limited to the examples described above, and various modifications are possible.

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

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

[0162] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN and / or LAN.

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

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

[0165] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS image sensor or CCD image sensor, which captures images of the area around the user (for example, an imaging range defined by a field of view equivalent to the field of vision of a typical healthy person).

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

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

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

[0169] The processor 28 reads a 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 acting as a specific processing unit 290 according to the specific processing program 56 executed on the RAM 30.

[0170] Storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290. The identification processing unit 290 can estimate the user's emotions using the emotion identification model 59 and perform identification processing using the user's emotions. The emotion estimation function (emotion identification function) using the emotion identification model 59 performs various estimations and predictions regarding the user's emotions, including but not limited to these examples. Furthermore, emotion estimation and prediction also include, for example, emotion analysis.

[0171] In robot 414, specific processing is performed by processor 46. A specific program 60 is stored in storage 50. Processor 46 reads the specific program 60 from storage 50 and executes it on RAM 48. The specific processing is achieved by processor 46 acting as a control unit 46A according to the specific program 60 executed on RAM 48. Robot 414 also has data generation model 58 and emotion identification model 59, similar to those of the robot, and can perform processing similar to that of the specific processing unit 290 using these models.

[0172] Furthermore, other devices besides the data processing device 12 may also have the data generation model 58. For example, a server device may have the data generation model 58. In this case, the data processing device 12 obtains processing results (such as prediction results) using the data generation model 58 by communicating with the server device that has the data generation model 58. Also, the data processing device 12 may be a server device or a terminal device owned by the user (for example, a mobile phone, robot, home appliance, etc.).

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

[0174] The data generation model 58 is a so-called generative AI. An example of a data generation model 58 is a generative AI such as ChatGPT. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and inference data such as audio data representing speech, text data representing text, and image data representing images (e.g., still image data or video data). The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference result in one or more data formats such as audio data, text data, and image data. The data generation model 58 includes, for example, text generation AI, image generation AI, and multimodal generation AI. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization. The specific processing unit 290 performs the specific processing described above using the data generation model 58. The data generation model 58 may be a fine-tuned model that outputs inference results from prompts that do not contain instructions, in which case the data generation model 58 can output inference results from prompts that do not contain instructions. In the data processing device 12, etc., there are multiple types of data generation models 58, and the data generation model 58 includes AI other than generative AI. AI other than generative AI includes, for example, linear regression, logistic regression, decision trees, random forests, support vector machines (SVM), k-means clustering, convolutional neural networks (CNN), recurrent neural networks (RNN), generative adversarial networks (GAN), or naive Bayes, and can perform various processes, but is not limited to these examples. Also, the AI ​​may be an AI agent. Furthermore, when the processing of each part described above is performed by the AI, the processing may be performed by the AI ​​in part or in whole, but is not limited to this example. Also, processing performed by an AI including a generative AI may be replaced by rule-based processing, and rule-based processing may be replaced by processing performed by an AI including a generative AI.

[0175] The data processing system 410 according to the fourth embodiment performs the same processing as the data processing system 10 according to the first embodiment. The processing by the data processing system 410 is performed by the specific processing unit 290 of the data processing device 12 or the control unit 46A of the robot 414, but it may also be performed by the specific processing unit 290 of the data processing device 12 and the control unit 46A of the robot 414. In addition, the specific processing unit 290 of the data processing device 12 acquires or collects information necessary for processing from the robot 414 or an external device, and the robot 414 acquires or collects information necessary for processing from the data processing device 12 or an external device.

[0176] Each of the multiple elements described above, including the static analysis unit, test generation unit, documentation generation unit, vulnerability detection unit, and UI testing unit, is implemented in at least one of the robot 414 and the data processing unit 12. For example, the static analysis unit is implemented by the processor 46 of the robot 414 or the specific processing unit 290 of the data processing unit 12. The test generation unit is implemented by the specific processing unit 290 of the data processing unit 12, for example, and creates test cases and generates test programs based on specifications. The documentation generation unit is implemented by the control unit 46A of the robot 414 or the specific processing unit 290 of the data processing unit 12, for example, and automatically generates relationship diagrams and transition diagrams. The vulnerability detection unit is implemented by the specific processing unit 290 of the data processing unit 12, for example, and detects vulnerabilities in the source code and suggests countermeasures. The UI testing unit is implemented by the control unit 46A of the robot 414 or the specific processing unit 290 of the data processing unit 12, for example, and automates user interface testing. The correspondence between each part and the device or control unit is not limited to the examples described above, and various modifications are possible.

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

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

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

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

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

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

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

[0184] In the above embodiment, an example was given in which a specific process is performed by a single computer 22. However, the technology of this disclosure is not limited thereto, and a distributed processing method for the specific process may be used, which includes computer 22 and multiple other computers.

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

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

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

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

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

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

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

[0192] Furthermore, although the above-described examples were divided into four embodiments, some or all of these embodiments may be combined. Also, the smart device 14, smart glasses 214, headset terminal 314, and robot 414 are just examples, and they may be combined, or other devices may be used. Also, although the above-described examples were divided into two embodiments, Embodiment 1 and Embodiment 2, these may be combined.

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

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

[0195] (Note 1) A static analysis unit that performs static analysis of the source code, A test generation unit that automatically generates a test program based on unnecessary processing and inefficient parts detected by the static analysis unit, A documentation generation unit that automatically generates relationship diagrams and transition diagrams based on the test program generated by the test generation unit, A vulnerability detection unit detects vulnerabilities based on documents generated by the documentation generation unit and proposes countermeasures, The system includes a UI testing unit that automates user interface testing based on vulnerabilities detected by the vulnerability detection unit. A system characterized by the following features. (Note 2) The static analysis unit described above is: It analyzes the source code to detect unnecessary processing and inefficient parts. The system described in Appendix 1, characterized by the features described herein. (Note 3) The test generation unit, Create test cases and generate test programs based on the specifications. The system described in Appendix 1, characterized by the features described herein. (Note 4) The documentation generation unit, The system automatically generates relationship diagrams and transition diagrams in response to changes and additions to the source code, and creates development documentation. The system described in Appendix 1, characterized by the features described herein. (Note 5) The vulnerability detection unit, Detects vulnerabilities in source code and suggests countermeasures. The system described in Appendix 1, characterized by the features described herein. (Note 6) The aforementioned UI testing unit is Automate user interface testing to reduce manual work. The system described in Appendix 1, characterized by the features described herein. (Note 7) The static analysis unit described above is: It estimates the user's emotions and adjusts the presentation method of the analysis results based on the estimated user emotions. The system described in Appendix 1, characterized by the features described herein. (Note 8) The static analysis unit described above is: Analyze the change history of the source code to identify inefficiencies created by specific developers. The system described in Appendix 1, characterized by the features described herein. (Note 9) The static analysis unit described above is: Evaluate the complexity of the source code and perform a detailed analysis on particularly complex parts. The system described in Appendix 1, characterized by the features described herein. (Note 10) The static analysis unit described above is: The system estimates the user's emotions and determines the priority of analysis based on the estimated emotions. The system described in Appendix 1, characterized by the features described herein. (Note 11) The static analysis unit described above is: When analyzing source code, adjust the depth of the analysis considering the progress of the development project. The system described in Appendix 1, characterized by the features described herein. (Note 12) The static analysis unit described above is: When analyzing source code, identify inefficient parts by comparing them with codebases from other projects. The system described in Appendix 1, characterized by the features described herein. (Note 13) The test generation unit, We estimate the user's emotions and adjust the test case generation method based on the estimated user emotions. The system described in Appendix 1, characterized by the features described herein. (Note 14) The test generation unit, When generating test cases, refer to past bug history to create test cases that reproduce specific bugs. The system described in Appendix 1, characterized by the features described herein. (Note 15) The test generation unit, When generating test cases, determine which parts of the code to focus on testing based on the changes made. The system described in Appendix 1, characterized by the features described herein. (Note 16) The test generation unit, We estimate the user's emotions and prioritize test cases based on those estimated emotions. The system described in Appendix 1, characterized by the features described herein. (Note 17) The test generation unit, When generating test cases, adjust the difficulty level of the test cases to take into account the developer's skill level. The system described in Appendix 1, characterized by the features described herein. (Note 18) The test generation unit, When generating test cases, new test cases are created by referencing test cases from other projects. The system described in Appendix 1, characterized by the features described herein. (Note 19) The documentation generation unit, It estimates the user's emotions and adjusts the way the document is presented based on those estimated emotions. The system described in Appendix 1, characterized by the features described herein. (Note 20) The documentation generation unit, When generating documentation, refer to the code's change history to highlight the changes. The system described in Appendix 1, characterized by the features described herein. (Note 21) The documentation generation unit, During document generation, automatically generate documents tailored to specific development phases. The system described in Appendix 1, characterized by the features described herein. (Note 22) The documentation generation unit, It estimates user sentiment and prioritizes documents based on the estimated user sentiment. The system described in Appendix 1, characterized by the features described herein. (Note 23) The documentation generation unit, When generating documentation, different documents are generated depending on the developer's role. The system described in Appendix 1, characterized by the features described herein. (Note 24) The documentation generation unit, When generating documentation, create new documentation by referencing documentation from other projects. The system described in Appendix 1, characterized by the features described herein. (Note 25) The vulnerability detection unit, We estimate user sentiment and adjust how vulnerabilities are presented based on that estimated sentiment. The system described in Appendix 1, characterized by the features described herein. (Note 26) The vulnerability detection unit, When detecting vulnerabilities, the system refers to past vulnerability history to focus on detecting specific vulnerabilities. The system described in Appendix 1, characterized by the features described herein. (Note 27) The vulnerability detection unit, When detecting vulnerabilities, the areas to focus on for detection are determined based on the code changes. The system described in Appendix 1, characterized by the features described herein. (Note 28) The vulnerability detection unit, It estimates user sentiment and prioritizes vulnerabilities based on the estimated user sentiment. The system described in Appendix 1, characterized by the features described herein. (Note 29) The vulnerability detection unit, When detecting vulnerabilities, we adjust the way vulnerabilities are presented to take into account the skill level of the developers. The system described in Appendix 1, characterized by the features described herein. (Note 30) The vulnerability detection unit, When a vulnerability is detected, new vulnerabilities are discovered by referencing vulnerability information from other projects. The system described in Appendix 1, characterized by the features described herein. (Note 31) The aforementioned UI testing unit is We estimate user emotions and adjust the UI testing process based on those estimated emotions. The system described in Appendix 1, characterized by the features described herein. (Note 32) The aforementioned UI testing unit is During UI testing, we perform tests to reproduce specific bugs by referring to past UI bug history. The system described in Appendix 1, characterized by the features described herein. (Note 33) The aforementioned UI testing unit is When conducting UI testing, refer to the user's operation history to determine which parts to focus on testing. The system described in Appendix 1, characterized by the features described herein. (Note 34) The aforementioned UI testing unit is We estimate user emotions and prioritize UI tests based on those estimated emotions. The system described in Appendix 1, characterized by the features described herein. (Note 35) The aforementioned UI testing unit is When conducting UI tests, adjust the test method taking into account the user's device information. The system described in Appendix 1, characterized by the features described herein. (Note 36) The aforementioned UI testing unit is When conducting UI tests, create new test cases by referring to UI test cases from other projects. The system described in Appendix 1, characterized by the features described herein. [Explanation of Symbols]

[0196] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Devices 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robots

Claims

1. A static analysis unit that performs static analysis of the source code, A test generation unit that automatically generates a test program based on unnecessary processing and inefficient parts detected by the static analysis unit, A documentation generation unit that automatically generates relationship diagrams and transition diagrams based on the test program generated by the test generation unit, A vulnerability detection unit detects vulnerabilities based on documents generated by the documentation generation unit and proposes countermeasures, The system includes a UI testing unit that automates user interface testing based on vulnerabilities detected by the vulnerability detection unit. A system characterized by the following features.

2. The static analysis unit described above is: It analyzes the source code to detect unnecessary processing and inefficient parts. The system according to feature 1.

3. The test generation unit, Create test cases and generate test programs based on the specifications. The system according to feature 1.

4. The documentation generation unit, The system automatically generates relationship diagrams and transition diagrams in response to changes and additions to the source code, and creates development documentation. The system according to feature 1.

5. The vulnerability detection unit, Detects vulnerabilities in source code and suggests countermeasures. The system according to feature 1.

6. The aforementioned UI testing unit is Automate user interface testing to reduce manual work. The system according to feature 1.

7. The static analysis unit described above is: It estimates the user's emotions and adjusts the presentation method of the analysis results based on the estimated user emotions. The system according to feature 1.

8. The static analysis unit described above is: Analyze the change history of the source code to identify inefficiencies created by specific developers. The system according to feature 1.

9. The static analysis unit described above is: Evaluate the complexity of the source code and perform a detailed analysis on particularly complex parts. The system according to feature 1.

10. The static analysis unit described above is: The system estimates the user's emotions and determines the priority of analysis based on the estimated emotions. The system according to feature 1.

Images