System

Abstract

To provide a system for efficiently creating a high-quality application.SOLUTION: Means for the user to input the requirement specification of the application by using a terminal, means for the server to analyze the received requirement specification and extract a specific program requirement based on the generated AI model, means for the server to automatically generate a program code based on the extracted program requirement, means for the server to also generate a test code for the automatically generated program code, and automatically execute a test based on the test code, means for the user to confirm the generated program code and the test result, and perform modification and customization if necessary, means for the user to perform final test and release preparation; Means for deploying to a server or cloud environment.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] In modern society, the decline in the working population and the shortage of human resources are becoming increasingly serious. Furthermore, because programming requires advanced specialized knowledge, launching a new business requires a great deal of time and cost. It is particularly difficult for beginners with no programming knowledge to develop applications. Against this backdrop, there is a demand for efficient methods to support rapid, high-quality application development. [Means for solving the problem]

[0005] This invention provides a system that uses generative AI to automatically generate most of the programming, and then has humans test and refine it to efficiently create high-quality applications. Specifically, we propose a system that includes the following means.

[0006] 1. A means for users to input application requirements using a terminal.

[0007] 2. A means for the server to analyze the received requirements specifications and extract specific program requirements based on the generative AI model.

[0008] 3. A means for automatically generating program code based on program requirements extracted by the server.

[0009] 4. A means for the server to generate test code for the automatically generated program code and automatically execute the tests.

[0010] 5. A means for users to review the generated program code and test results and make modifications and customizations as needed.

[0011] 6. A means for users to perform final testing and release preparation and deploy to a server or cloud environment.

[0012] This allows even beginners with no programming knowledge to easily develop applications, alleviating labor shortages and improving work efficiency.

[0013] A "user" is an individual or organization that uses the system, and is responsible for inputting application requirements and verifying and correcting the generated program code and test results.

[0014] A "terminal" refers to a device used by a user, such as a computer, smartphone, or tablet, that provides an interface for entering required specifications and checking and modifying the generated code.

[0015] The "server" is a central computer system that receives and analyzes requirements from users, automatically generates program code using generative AI models, and also generates and executes test code.

[0016] A "generative AI model" is an artificial intelligence model that automatically generates specific program requirements and program code based on given requirements specifications.

[0017] A "requirements specification" is a natural language expression of the functions and features that a user requires when developing an application, and is the material that the server analyzes and converts into specific requirements.

[0018] "Program code" refers to a series of instructions or scripts that control the operation of an application, and is automatically generated by the server using a generative AI model.

[0019] "Test code" is code used to verify the operation of generated program code, and is used to discover and fix bugs and defects through unit testing and integration testing.

[0020] "Deployment" refers to the process of placing a completed application on a server or cloud environment so that it can actually be used by users.

[0021] "Customization" refers to the process in which a user adds specific functions or modifies the generated program code to suit their own requirements.

[0022] "Testing" refers to the process of verifying whether the generated program code operates correctly, and includes automatically generated test code and final testing by the user. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0031] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0044] The present invention is an application development support system that utilizes generative AI, which automatically generates most of the program, and then has humans test and refine it to efficiently create high-quality applications. The following describes in detail the embodiments of the present invention.

[0045] 1. Main components

[0046] This system mainly consists of the following components:

[0047] User: Enters application requirements and reviews / modifies the generated code.

[0048] Terminal: A device used by the user to perform operations, providing a UI for inputting requirements and checking and modifying code.

[0049] Server: Analyzes the requirements specifications, automatically generates program code using a generative AI model, and also generates and executes test code.

[0050] 2. System Operation Overview

[0051] The operation of this system will be specifically explained below.

[0052] User input of requirements

[0053] The user uses a terminal to input the application requirements in natural language. For example, they might input something like, "I want to create a task management app that allows users to add, edit, and delete tasks."

[0054] Submitting and analyzing requirements

[0055] The terminal sends the requirements entered by the user to the server, which analyzes the received requirements and extracts specific program requirements based on the generative AI model. At this stage, the necessary database structure, API endpoints, etc. are defined.

[0056] Automatic program generation

[0057] The server automatically generates back-end and front-end program code based on the extracted program requirements. Specifically, it generates database models and API endpoints for the back-end, and UI components for the front-end.

[0058] Generate and run test code

[0059] The server also generates corresponding test code for the generated program code and automatically runs the tests, running basic unit and integration tests to uncover early bugs.

[0060] Human review and correction

[0061] The user uses a terminal to check the generated program code and test results, and if necessary, modify or customize the code. This is also the stage where the user can add their own functions or fine-tune the UI.

[0062] Release preparation and deployment

[0063] Finally, the user prepares the release, which includes checking configuration files and deployment scripts, and then deploys the application to a server or cloud environment, making it live and available to users.

[0064] Example: Task management app

[0065] As an example, consider a simple task management app that allows users to add, edit, and delete tasks.

[0066] 1. The user enters the requirements specification using a terminal.

[0067] 2. The server parses the requirements and defines the database structure (e.g., task table) and API endpoints.

[0068] 3. The server uses the generative AI model to automatically generate back-end and front-end program code.

[0069] 4. The server also generates test code for unit tests and integration tests and runs them automatically.

[0070] 5. The user reviews the generated code and test results and corrects any deficiencies or errors.

[0071] 6. Once the checks and corrections are complete, the user prepares the release and deploys the application.

[0072] In this way, by utilizing generative AI, the present invention provides an environment in which even beginners with no programming knowledge can easily develop high-quality applications. It is also effective in alleviating the declining labor force and labor shortages.

[0073] The processing flow will be explained below.

[0074] Step 1:

[0075] The user uses the device to enter the application requirements. Specifically, the user enters the requirements in natural language into a form or text area on the device, such as "I want to create a task management app. I want to provide a function that allows users to add, edit, and delete tasks." When the user has completed the input, they click the submit button.

[0076] Step 2:

[0077] The terminal sends the user's required specifications to the server. Specifically, it sends the required specifications to the server as an HTTP POST request. At this time, the terminal converts the input data into an appropriate format and performs error checks before sending it to the server.

[0078] Step 3:

[0079] The server analyzes the requirements received. Specifically, it uses natural language processing technology to convert the input requirements into program requirements. For example, from the requirements for a "task management app," it extracts that a "task table" and "CRUD operations" are required.

[0080] Step 4:

[0081] The server uses the generative AI model to automatically generate specific program code. For example, back-end code using Django and front-end code using React are generated. The server stores this code in an internal database.

[0082] Step 5:

[0083] The server also automatically generates and executes test code. Specifically, it generates unit test code and integration test code and executes the tests on the generated program code. The test results are managed within the server and used for subsequent processing.

[0084] Step 6:

[0085] The server compiles the test results and sends them to the device. Specifically, it generates a detailed report including the success / failure results of the test and an error log, and sends it to the device. This allows the user to check the quality of the generated code.

[0086] Step 7:

[0087] The user uses the terminal to check the generated program code and test results, specifically, opens the code using an IDE or text editor on the terminal, reviews the test results, and modifies or customizes the code as needed.

[0088] Step 8:

[0089] The user performs final testing and fixes, specifically testing the modified and customized code again to ensure all test cases pass, and repeating this process until the problem is resolved.

[0090] Step 9:

[0091] The user prepares for release and deploys the application. Specifically, the user checks the configuration files and deployment scripts, and executes the deployment command from the terminal to the server or cloud environment. If the deployment is successful, the application actually starts running.

[0092] Through each of these steps, the system of the present invention enables even beginners with no programming knowledge to develop high-quality applications quickly and efficiently.

[0093] Example 1

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

[0095] Modern application development requires advanced programming knowledge, making it difficult for beginners and non-technical people to develop high-quality applications. To improve development efficiency, it is necessary to not only automatically generate code, but also to integrate a series of tasks, such as automatic testing and deployment. Furthermore, the declining workforce and labor shortages are becoming more serious problems. A system that can solve these issues and enable efficient, high-quality application development is needed.

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

[0097] In this invention, the server includes: a means for a user to input application requirements using a terminal; a means for the terminal to transmit the user's requirements to the server; a means for the server to analyze the received requirements and extract specific program requirements based on a generative AI model using natural language processing technology; a means for the server to automatically generate back-end code and front-end code based on the extracted program requirements; a means for the server to generate test code for the automatically generated program code and automatically perform unit tests and integration tests based on the test code; a means for the user to check the generated program code and test results using a terminal and make modifications and customizations as necessary; and a means for the user to perform final testing and release preparation and deploy to a server or cloud environment. This enables even users with little programming knowledge to efficiently develop advanced applications. It also provides an innovative development environment that can address the declining workforce and labor shortages.

[0098] "User" refers to a person or organization whose role is to input application requirements specifications and to review and modify the generated program code and test results.

[0099] A "terminal" is a device that is operated by the user and provides a user interface for inputting required specifications and checking and modifying code.

[0100] "Server" refers to a computer system that has the ability to analyze user requirements and automatically generate program code using a generative AI model, as well as the ability to generate and execute test code.

[0101] "Requirements specifications" refers to information written in natural language by a user describing the functions and characteristics required for an application.

[0102] "Natural language processing technology" refers to technology for processing and analyzing human language using a computer.

[0103] A "generative AI model" refers to an artificial intelligence model that automatically generates program code and requirements based on provided data.

[0104] "Program requirements" refers to elements for defining the structure and functions of a specific program based on the analyzed requirements specifications.

[0105] "Back-end code" refers to the program code that performs the server-side processing of an application.

[0106] "Front-end code" refers to the program code that builds the user interface and manages the user's interaction with the application.

[0107] "Test code" refers to code for verifying the operation of generated program code.

[0108] A "unit test" refers to a test that verifies the operation of an individual program unit.

[0109] "Integration testing" refers to testing that verifies the operation of multiple program units combined together.

[0110] A "cloud environment" refers to an environment for using server resources and applications provided via the Internet.

[0111] This invention relates to an application development support system that utilizes a generative AI model. This system automatically generates program code and test code based on user-provided requirements, providing a method for efficiently developing high-quality applications.

[0112] Main components

[0113] This system mainly consists of the following components:

[0114] User: Enters application requirements and reviews / modifies the generated code.

[0115] Terminal: A device used by the user to perform operations, providing a user interface for inputting requirements and checking and modifying code.

[0116] Server: Analyzes the requirements specifications, automatically generates program code using a generative AI model, and generates and executes test code.

[0117] System Operation Overview

[0118] The operation of the system proceeds as follows.

[0119] Input of required specifications

[0120] The user inputs the application requirements in natural language using a terminal, for example, by entering the following prompt sentence:

[0121] I want to create a task management app that allows users to add, edit, and delete tasks.

[0122] Submitting and analyzing requirements

[0123] The terminal sends the requirements entered by the user to the server. The server analyzes the received requirements using natural language processing technology and extracts specific program requirements based on a generative AI model. Specifically, it extracts keywords and structures using natural language processing libraries such as SpaCy and NLTK, and inputs them into a generative AI model (e.g., GPT-3 (registered trademark)) to generate program requirements.

[0124] Automatic program generation

[0125] The server automatically generates program code based on the analysis results. The back-end code is primarily generated using Python and Flask, while the front-end code is generated using frameworks such as React. The database structure and API endpoints are also defined at the same time.

[0126] Generate and run test code

[0127] The server automatically generates test code for the generated program code, and uses test frameworks such as PyTest and Jest to run unit tests and integration tests and obtain test results.

[0128] Check and fix the code

[0129] The user can then use a terminal to review the generated program code and test results, modifying or customizing the code as needed. During this step, real-time code validation and suggestions are provided using a code editor such as VSCode.

[0130] Release preparation and deployment

[0131] Finally, the user checks the generated program configuration files and deployment scripts, and deploys the application to a cloud environment (e.g., AWS (registered trademark), Azure (registered trademark), or GCP), which makes the application available for use.

[0132] Specific examples

[0133] Here is a simple example of a task management app. The user enters the following prompt from the terminal:

[0134] I want to create a task management app that allows users to add, edit, and delete tasks.

[0135] Based on the above input, the server analyzes the requirements and defines the database structure for the task table and the necessary API endpoints. It then uses a generative AI model to automatically generate backend code (using Python and Flask) and frontend code (using React), and creates and runs test code for each. The user can then review and modify the generated code, and finally deploy it to a cloud environment. This series of processes enables the efficient development of a high-quality task management app.

[0136] This system allows even users with little programming knowledge to efficiently develop advanced applications, providing an effective development environment to address the declining workforce and labor shortages.

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

[0138] Step 1:

[0139] The user uses a device to input the application requirements. The user provides input in natural language into a form on the device. A specific example of input is provided: "I want to create a task management app. I want to provide functionality that allows users to add, edit, and delete tasks." This input prompt becomes the data for the next process.

[0140] Step 2:

[0141] The terminal sends the requirements entered by the user to the server. When the send button on the terminal is clicked, the requirements are sent to the server via the network. At this time, the entered natural language text is sent to the server endpoint as a POST request (input: natural language requirements, output: requirements passed to the server).

[0142] Step 3:

[0143] The server analyzes the received requirements using natural language processing techniques. For example, the server uses libraries such as SpaCy or NLTK to tokenize the text and extract key keywords and grammatical structures (input: natural language requirements, output: keywords and structured data).

[0144] Step 4:

[0145] The server provides prompts to the generative AI model based on the analysis results and extracts specific program requirements. The server generates program requirements from the requirements specification using, for example, GPT-3. These requirements include the database structure and API endpoints (input: analysis results, output: program requirements).

[0146] Step 5:

[0147] The server automatically generates back-end and front-end code based on the extracted program requirements. The back-end code is generated using Python and Flask, and the front-end code is generated using React (input: program requirements, output: automatically generated code).

[0148] Step 6:

[0149] The server generates test code for the generated program code and automatically executes unit tests and integration tests based on the generated code. For example, it generates test code using a test framework such as PyTest or Jest and automatically executes the tests (input: generated program code, output: test results).

[0150] Step 7:

[0151] The user can view the generated program code and test results using a terminal. A code editor (e.g., VSCode) or browser is displayed on the terminal, where the user can modify and customize the code (input: generated code and test results, output: modified code).

[0152] Step 8:

[0153] The user performs final testing and release preparation, then deploys to a server or cloud environment. The user checks the configuration files and deployment scripts and executes the deployment to the appropriate environment (input: final code and configuration files, output: deployed application).

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

[0155] (Application example 1)

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

[0157] Demand for video streaming services is increasing in modern society. However, operating a video streaming service requires advanced technical skills and significant resources, making it difficult for individuals and small and medium-sized enterprises to easily launch and operate a service. Furthermore, the complex development process and numerous testing and deployment procedures make it difficult to provide services quickly. Furthermore, while appropriate testing and user interface design are required to ensure code quality, there is a lack of automated methods for these processes.

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

[0159] In this invention, the server includes: a means for a user to input application requirements using a terminal; a means for the server to analyze the received requirements and extract specific program requirements based on a generative AI model; a means for the server to automatically generate program code based on the extracted program requirements; a means for the server to generate test code for the automatically generated program code and automatically run tests based on the test code; a means for the user to review the generated program code and test results and modify and customize it as necessary; a means for the user to perform final testing and release preparation and deploy it to a server or cloud environment; and a means for automatically generating functions for a video streaming service, allowing users to upload videos and for viewers to comment. This allows users to easily start and operate a video streaming service without advanced technical knowledge. Furthermore, automatic code generation and testing enables rapid and high-quality service provision.

[0160] "User" refers to a person or organization that inputs application requirements specifications, and reviews, modifies, customizes, and prepares the generated program code and test results for release.

[0161] A "terminal" is a device that a user operates and provides a user interface for inputting required specifications and checking and modifying code.

[0162] "Requirements specifications" are requirements regarding the functions and features of an application that are input by the user in natural language.

[0163] A "server" is a device or system that analyzes requirements received from a user, automatically generates program code and test code using a generative AI model, and then automatically executes tests based on this code.

[0164] A "generative AI model" is an artificial intelligence model that extracts specific program requirements based on required specifications and automatically generates corresponding program code.

[0165] "Program requirements" refer to the specific program components and functions extracted by the generative AI model.

[0166] "Program Code" means the back-end and front-end source code automatically generated by the Server.

[0167] "Test code" refers to code generated to check the basic operation of the generated program code.

[0168] "Deployment" refers to the procedure in which a user places the final application on a server or cloud environment and makes it available for use by users.

[0169] A "video streaming service" is a service that allows users to distribute videos over the Internet and allows viewers to watch those videos in real time or on demand.

[0170] The present invention provides an application development support system using a generative AI model, which supports automatic program generation and video streaming service operation. The following describes in detail an embodiment of the present invention.

[0171] Main components

[0172] The system mainly consists of the following components:

[0173] User: Enters application requirements and checks and modifies the generated program code and test results.

[0174] Terminal: A device used by the user to perform operations, providing a user interface for inputting requirements and checking and modifying code.

[0175] Server: Analyzes requirements specifications, automatically generates program code and test code using a generative AI model, and automatically executes tests based on this code.

[0176] System Operation Overview

[0177] Input of required specifications

[0178] The user uses a terminal to input the required specifications for the video streaming service in natural language. For example, they might input something like, "I want to create a video streaming service that allows users to upload videos and provides a function that allows viewers to comment."

[0179] Analysis of requirements specifications and extraction of program requirements

[0180] The server analyzes the received requirements and extracts specific program requirements based on the generative AI model, which defines the necessary database structure, API endpoints, etc.

[0181] Automatic generation of program code

[0182] The server automatically generates program code based on the extracted program requirements. For example, database models and API endpoints are defined on the backend, and UI components are automatically generated on the frontend. Specific features for video streaming services (such as video uploads and viewer comment functions) are also automatically generated.

[0183] Test code generation and automatic execution

[0184] The server then generates test code for the generated program code and automatically executes the tests, conducting unit tests and integration tests to identify any early defects.

[0185] Check and fix

[0186] The user uses a terminal to check the generated program code and test results, and can modify or customize the code as needed. This is also the stage where users can add their own functions or fine-tune the UI.

[0187] Release preparation and deployment

[0188] Finally, the user prepares the release and deploys it to a server or cloud environment, which then provides the actual video streaming service.

[0189] Hardware and software used

[0190] Hardware: Smartphone, PC (user device)

[0191] Software: Python, generative AI models, general-purpose frameworks, streaming servers (e.g., NGINX, Wowza)

[0192] Specific examples

[0193] Here is an example of a simple prompt:

[0194] "Generate application code for a video streaming service. It should allow users to upload videos and viewers to comment. It should also include a user management system."

[0195] Based on this prompt, the generative AI model automatically generates application code, which the user can review and modify before finally deploying.

[0196] This invention allows users to easily launch and operate a video streaming service without advanced technical knowledge, and the automatic code generation and testing enables rapid and high-quality service provision.

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

[0198] Step 1:

[0199] A user uses a device to input the requirements for a video streaming service in natural language. For example, they might input, "I want to create a video streaming service that allows users to upload videos and viewers to comment." This requirement becomes the input for the system.

[0200] Step 2:

[0201] The terminal sends the requirements input by the user to the server. At this stage, the requirements are sent in natural language as input data. The server receives them and prepares to start analysis.

[0202] Step 3:

[0203] The server analyzes the received requirements and extracts specific program requirements based on a generative AI model. The generative AI model analyzes the natural language requirements, identifies the necessary database structure and API endpoints, and outputs the program requirements. Specific operations include text data analysis and natural language processing.

[0204] Step 4:

[0205] Based on the program requirements extracted by the server, back-end and front-end program code is automatically generated. The generative AI model generates code based on the input program requirements and outputs the results. Specifically, the database model and API are defined on the back-end, and user interface components are generated on the front-end.

[0206] Step 5:

[0207] The server generates test code corresponding to the automatically generated program code and automatically executes the tests. Based on the input program code, it generates the necessary unit tests and integration tests and executes them. A report of the test results is obtained as output. Specifically, it performs static analysis of the code and executes dynamic tests.

[0208] Step 6:

[0209] The user uses a terminal to check the generated program code and test results. The inputs are the test result report and the generated program code, and the user can modify or customize it as needed. Specifically, modifications are made using a code editor or debugging tool.

[0210] Step 7:

[0211] The user performs final testing and release preparation, then deploys to a server or cloud environment. The input is the modified program code and configuration files, and the deployment is based on these. The output is a working video streaming service. Specific operations include running the deployment script and applying the server settings.

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

[0213] The present invention is an application development support system that utilizes generative AI and incorporates an emotion engine that recognizes user emotions. High-quality applications are efficiently created by automatically generating the majority of the program, followed by human testing and refinement. The following describes in detail the embodiments of the present invention.

[0214] 1. Main components

[0215] This system mainly consists of the following components:

[0216] User: Enters application requirements and reviews / modifies the generated code.

[0217] Terminal: A device used by the user to perform operations, providing a UI for inputting requirements and checking and modifying code.

[0218] Server: Analyzes the requirements specifications, automatically generates program code using a generative AI model, and also generates and executes test code.

[0219] Emotion engine: Recognizes user emotions and provides feedback to the overall system behavior.

[0220] 2. System Operation Overview

[0221] The operation of this system will be specifically explained below.

[0222] User input of requirements

[0223] The user uses a device to input the application requirements in natural language. For example, they might input something like, "I want to create a task management app. It should provide functions that allow users to add, edit, and delete tasks." At this time, the emotion engine recognizes and records the user's emotions from facial expressions, voice, and other factors.

[0224] Submitting and analyzing requirements

[0225] The device sends the requirements entered by the user to the server, which analyzes the received requirements and extracts specific program requirements based on the generative AI model. At this stage, the user's emotional data provided by the emotion engine is also reflected in the analysis results.

[0226] Automatic program generation

[0227] The server automatically generates back-end and front-end program code based on the extracted program requirements. For example, database models and API endpoints are generated on the back-end, and UI components are generated on the front-end. The UI design and color may also be adjusted based on the user's emotions.

[0228] Generate and run test code

[0229] The server also generates corresponding test code for the generated program code and automatically executes the tests. This executes basic unit tests and integration tests to identify early-stage bugs. The test results are managed within the server and used for subsequent processing.

[0230] Human review and correction

[0231] The user uses the device to check the generated program code and test results. Specifically, they open the code using the device's IDE or text editor and review the test results. They can then modify or customize the code as needed. The emotion engine also collects user emotion data during the project and provides feedback and suggestions for improvement.

[0232] Release preparation and deployment

[0233] Finally, the user prepares the release, which includes checking configuration files and deployment scripts. The user then deploys the application to a server or cloud environment. If the deployment is successful, the application goes live.

[0234] Example: Task management app

[0235] As an example, consider a simple task management app that allows users to add, edit, and delete tasks.

[0236] 1. The user inputs the required specifications using a terminal. At this time, the emotion engine analyzes the user's facial expressions and voice and records emotional data.

[0237] 2. The server analyzes the requirements and defines the database structure (e.g., task table) and API endpoints. Emotion data is also used for analysis.

[0238] 3. The server uses the generative AI model to automatically generate back-end and front-end program code. The UI design may be adjusted based on the emotion data.

[0239] 4. The server also generates test code for unit tests and integration tests and runs them automatically.

[0240] 5. The user reviews the generated code and test results, and fixes any deficiencies or errors. The emotion engine provides user feedback.

[0241] 6. Once the checks and corrections are complete, the user prepares the release and deploys the application.

[0242] In this way, by utilizing generative AI and an emotion engine, this invention enables even beginners with no programming knowledge to quickly and efficiently develop high-quality applications. In addition, by taking user emotions into consideration, it is possible to provide more intuitive and easy-to-use applications.

[0243] The processing flow will be explained below.

[0244] Step 1:

[0245] The user uses the device to input the application requirements. For example, the user might enter a requirement in natural language into a form or text area on the device, such as "I want to create a task management app. It should provide the ability for users to add, edit, and delete tasks." At this time, the emotion engine recognizes the user's face and analyzes their voice, and records their emotional data.

[0246] Step 2:

[0247] The device sends the user's requirements and emotion data to the server. Specifically, it sends the requirements entered using an HTTP POST request and the data collected by the emotion engine to the server.

[0248] Step 3:

[0249] The server analyzes the received requirements and emotion data. It then uses natural language processing technology to convert the requirements into program requirements and corrects the analysis results based on the emotion data. For example, if the user is nervous, it generates suggestions to simplify the interface to improve the user experience.

[0250] Step 4:

[0251] The server uses the generative AI model to automatically generate specific program code. For example, it generates back-end code using Django and front-end code using React. During this process, the UI color and design may change depending on the user's emotions.

[0252] Step 5:

[0253] The server also automatically generates test code and executes the tests. Specifically, it generates unit test code and integration test code and executes the tests on the generated application code. The test results are managed within the server and used for subsequent processing.

[0254] Step 6:

[0255] The server compiles the test results and sends them to the device. A detailed report is generated and sent to the device, including test success / failure results and error logs. The user can then check the quality of the generated code based on this.

[0256] Step 7:

[0257] The user uses the terminal to view the generated program code and test results, opens the code using an IDE or text editor on the terminal, reviews the test results, and modifies and customizes the code as needed.

[0258] Step 8:

[0259] The user performs final testing and fixes. The fixed and customized code is retested to ensure all test cases pass. This process is repeated until the issue is resolved.

[0260] Step 9:

[0261] The user prepares for release and deploys the application. They check the configuration files and deployment scripts, and execute the deployment command from the terminal to the server or cloud environment. If the deployment is successful, the application actually starts running.

[0262] Through these steps, the system of the present invention enables even beginners with no programming knowledge to quickly and efficiently develop high-quality applications. Furthermore, the emotion engine provides customization according to the user's emotions, improving the user experience.

[0263] Example 2

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

[0265] In the current application development process, automatic generation and testing of program code requires specialized knowledge, making it difficult for beginners and non-experts to develop efficiently.In addition, while the importance of interfaces and feedback that take user emotions into account is increasing, there is no system that can automatically reflect this.

[0266] The specification processing by the specification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes: means for a user to input application requirement specifications using a terminal; means for the server to analyze the received requirement specifications and extract specific program requirements based on a generative AI model; means for the server to automatically generate program code based on the extracted program requirements; means for the server to generate test code for the automatically generated program code and automatically execute tests based on the test code; means for a user to check the generated program code and test results and modify and customize it as necessary; means for a user to perform final testing and release preparation and deploy it to a server or cloud environment; and means for collecting and analyzing user emotion data using an emotion engine and providing feedback to the operation of the entire system. This allows even users without programming knowledge to efficiently develop high-quality applications, and enables interfaces and feedback that take user emotions into consideration to be automatically reflected.

[0267] A "terminal" is a device that a user operates, and is a device that allows text input and screen operation.

[0268] A "server" is a computer system that receives requests over a network and performs the specified processing.

[0269] "Requirements specifications" are documents or inputs that describe the specific requirements, such as the functions and performance, of the application that the user wants to develop.

[0270] A "generative AI model" is an artificial intelligence model used to analyze received requirements specifications and automatically generate specific program requirements.

[0271] "Program code" is code that describes specific instructions for a computer to execute.

[0272] "Test code" is code created to verify the accuracy and performance of generated program code.

[0273] "Test results" are the output and verification results obtained when test code is executed, and indicate the soundness of the program.

[0274] The "emotion engine" is a component that recognizes emotions from the user's facial expressions and voice, and provides feedback to the operation of the entire system.

[0275] "Deployment" is the process of placing an application that has been developed on a server or in a cloud environment and running it.

[0276] "Back-end code" is program code that runs on the server side and is responsible for managing databases and logic.

[0277] "Front-end code" is the program code that manages the interface with which the user directly interacts and the user interactions.

[0278] A "unit test" is a test that verifies the correctness of individual parts or components of a program.

[0279] "Integration testing" is testing that verifies whether multiple components or the entire system work together correctly.

[0280] "Natural language" refers to the language used by humans on a daily basis, and refers to the terms used in writing and conversation, rather than a specific programming language.

[0281] This invention is an application development support system that utilizes a generative AI model and an emotion engine. This system automatically generates program code based on user requirements and reflects the user's emotions as feedback in the overall system operation, thereby achieving efficient and high-quality application development.

[0282] System configuration

[0283] This system mainly consists of the following components:

[0284] Terminal: A device operated by the user that provides an interface for inputting required specifications and checking and correcting the generated code. The terminal is equipped with an emotion engine that recognizes emotions from the user's facial expressions and voice, and records the data.

[0285] Server: Analyzes the requirements specifications sent by the user and extracts specific program requirements using a generative AI model. It also has the ability to automatically generate program code and test code based on the extracted requirements and execute the tests.

[0286] Emotion engine: Collects and analyzes user emotional data and provides feedback to the system based on this.

[0287] Operation overview

[0288] The operation of this system will be specifically outlined below.

[0289] The user inputs the requirements for the application they wish to develop in natural language from their device. For example, they might input something like, "I want to create a task management app. It will provide a function that allows users to add, edit, and delete tasks." The device is equipped with an emotion engine that analyzes the user's facial expressions and voice to collect emotional data, which is then sent to the server along with the requirements.

[0290] When the server receives the requirements, it analyzes them using a generative AI model (e.g., GPT-4 (registered trademark)) to extract specific program requirements. The analysis results also reflect the user's emotional data. For example, if the system determines that the user has time to spare, it can suggest more advanced features to the user.

[0291] The server then automatically generates backend (e.g., Node.js, Express, MongoDB) and frontend (e.g., React, Bootstrap) program code based on the extracted program requirements. Depending on the emotion data, the UI design and color scheme may also be adjusted.

[0292] The server then automatically generates unit and integration test code for the generated program code and immediately runs the tests. The test results are managed within the server, and initial bugs and issues can be identified based on the results.

[0293] The user can then use their device to check the generated program code and test results, and make any necessary modifications or customizations. During this process, the emotion engine analyzes the user's emotional data and provides appropriate feedback.

[0294] Finally, users prepare for release, check the configuration files and deployment scripts, and then deploy the application to a server or cloud environment to run it. Through this process, users can develop efficient and high-quality applications quickly.

[0295] Specific examples

[0296] As a specific example, a scene in which a user inputs the following prompt sentence will be shown.

[0297] I want to create a task management app that allows users to add, edit, and delete tasks.

[0298] Based on these requirements, the server analyzes them using a generative AI model and automatically generates the necessary program code and test code. The emotion engine detects the user's sense of security and stress, and provides feedback to adjust the UI and suggest improvements. This allows users to efficiently develop task management apps with intuitive and easy-to-use interfaces.

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

[0300] Step 1: Enter requirements

[0301] The user uses a device to input the application requirements in natural language. Specifically, they enter "I want to create a task management app. I want to provide a function that allows users to add, edit, and delete tasks" into an input field on the device's UI. At this time, the emotion engine analyzes the user's facial expressions and voice and collects emotional data. The inputs are the requirements and emotional data, which are converted into a data format and sent to the server as output.

[0302] Step 2: Submit your requirements

[0303] The device sends the request specifications and emotion data entered by the user to the server. Specifically, it uses a REST API or WebSocket to send a request including the request specifications and emotion data. The request specifications and emotion data are used as input, and the server receives them as output.

[0304] Step 3: Analyze requirements

[0305] The server analyzes the received requirements and uses a generative AI model (e.g., GPT-4) to extract specific program requirements. Emotional data is also used in the analysis, taking into account the user's emotions. The input is the requirements and emotional data, and the output is defined as program requirements.

[0306] Step 4: Automatic program generation

[0307] The server automatically generates program code based on the extracted program requirements. Using a generative AI model, back-end and front-end code is generated. For example, database models and API endpoints are generated for the back-end, and UI components are generated for the front-end. The program requirements are used as input, and the generated program code is obtained as output.

[0308] Step 5: Generate and run test code

[0309] The server automatically generates test code for the generated program code and executes the tests, including unit tests and integration tests. The input is the generated program code, and the test code is generated and executed, resulting in the test results as output.

[0310] Step 6: Human review and correction

[0311] The user uses the terminal to review the generated program code and test results. Specifically, they open the code in the terminal's IDE or text editor and make modifications and customizations as needed. The emotion engine provides feedback based on the user's progress. The input is the generated code and test results, and the output is the modified code and comments.

[0312] Step 7: Release preparation and deployment

[0313] The user prepares for release. After checking the configuration files and deployment scripts and completing the final checks, the user deploys the application to the server or cloud environment. Specifically, the deployment is performed by executing a command. The input is the finalized program code, and the output is a working application.

[0314] (Application example 2)

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

[0316] Conventional application development support systems have difficulty providing interfaces and functions that take user emotions into account, limiting the improvement of user experience. Furthermore, they are unable to intuitively recommend products based on user emotions in virtual stores, resulting in a less satisfying shopping experience.

[0317] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: means for a user to input application requirement specifications using a terminal; means for analyzing the received requirement specifications and extracting specific program requirements based on a generative AI model; means for automatically generating program code based on the extracted program requirements; means for generating test code for the automatically generated program code and automatically running tests based on the generated test code; means for checking the generated program code and test results, and modifying and customizing it as necessary; means for performing final testing and preparing for release, and deploying it to a server or cloud environment; means for recognizing user emotions using an emotion engine and providing feedback to the operation of the entire system; and means for displaying recommended products based on the user's emotion data. This enables customization based on the user's emotions, providing an intuitive and satisfying shopping experience in a virtual store.

[0318] "User" is the individual or end user who inputs the application requirements and reviews and modifies the generated code.

[0319] A "terminal" is a device that is operated by a user and provides a user interface for inputting required specifications and checking and correcting code.

[0320] A "server" is a computer system that analyzes the received requirements specifications, automatically generates program code and test code based on a generative AI model, and oversees processing on the system.

[0321] A "generative AI model" is an artificial intelligence model that extracts specific program requirements based on the requirements specifications entered by the user and automatically generates code.

[0322] "Program requirements" are specifications for specific functions and processes extracted based on the requirements analyzed by the generative AI model.

[0323] "Program code" refers to source code that is automatically generated by a generative AI model to realize various functions and processes.

[0324] "Test code" is code used to verify the operation of automatically generated program code.

[0325] The "emotion engine" is an engine that recognizes emotions from the user's facial expressions and voice and provides feedback to the system's operation.

[0326] "Recommended products" are products or services that are suggested to a user based on the user's emotional data recognized using the emotion engine.

[0327] "Deployment" is a method of transferring developed program code to an environment where it can actually be used and arranging it so that it can run.

[0328] The system that realizes this application example consists of the following elements: The user uses a terminal to input the application requirements in natural language. For example, they might input something like, "I want to create a task management app. It should provide a function that allows users to add, edit, and delete tasks." At this time, the emotion engine recognizes and records the user's emotions from their facial expressions, voice, etc.

[0329] The server analyzes the received requirements and extracts specific program requirements based on a generative AI model. The server then automatically generates back-end code (e.g., Django) and front-end code (e.g., React) based on the extracted program requirements. The UI design and color may be adjusted depending on the user's emotions, providing a user-friendly interface.

[0330] Next, the server generates test code for the automatically generated program code and automatically executes the tests. At this stage, basic unit tests and integration tests are performed to identify early bugs. The test results are managed within the server and provided to users for review and correction.

[0331] Users can use their devices to check the generated program code and test results, and correct any deficiencies or errors. The emotion engine collects users' emotional data during the project and provides feedback and suggestions for improvements based on this data, allowing users to work intuitively.

[0332] Finally, the user prepares the release, which includes checking configuration files and deployment scripts, after which the user deploys the application to a server or cloud environment and the application starts running.

[0333] A concrete example is a virtual store application. When a user launches the app, the camera captures the user's face and recognizes their emotions in real time. Based on the recognized emotional data, a list of recommended products is displayed. In this case, the hardware used is the smartphone's camera and microphone, and the software used is EmotionRecognizer and ProductRecommender.

[0334] Examples of prompts include:

[0335] "Please enter an image of the user smiling."

[0336] In this way, an application development support system that utilizes emotion recognition technology can be customized to suit the user's emotions, providing more intuitive and easy-to-use applications.

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

[0338] Step 1:

[0339] The user uses a device to input the application requirements in natural language. At this time, the user uses the interface on the device to input content such as, "I want to create a task management app. I want to provide a function that allows users to add, edit, and delete tasks." The user's requirements are sent as text data to the device as input. The device then sends this text data to the server.

[0340] Step 2:

[0341] The server analyzes the received requirements specification. It uses a generative AI model to extract specific program requirements from the text data. The input is the text data of the user's requirements specification, and the output is a list of specific program requirements. This analysis process uses natural language processing techniques to break down the text and extract key phrases and syntax.

[0342] Step 3:

[0343] The server automatically generates program code based on the extracted program requirements. The server uses a generative AI model to generate back-end code (using Django, for example) and front-end code (using React, for example). The output is a specific program code file.

[0344] Step 4:

[0345] The server generates corresponding test code for the automatically generated program code and automatically executes the tests based on this. The generated program code is used as input and goes through a transformation process to generate test code. The output is a log of the test results. The server systematically executes unit tests and integration tests to detect basic bugs and errors.

[0346] Step 5:

[0347] The user accesses the generated program code and test results using a terminal to view them. The user can view the code using an ID or text editor on the terminal and modify and customize it as needed. In this step, the user receives feedback generated based on the data analyzed by the emotion engine. The input is the generated code and test results, and the output is the modified and customized program code.

[0348] Step 6:

[0349] The user performs final testing and release preparation. Using a terminal, the user checks configuration files and deployment scripts and prepares the application for deployment to a server or cloud environment. The input is the finalized program code and configuration files, and the output is the deployed application, which is transferred to a working environment.

[0350] Step 7:

[0351] The emotion engine recognizes emotions from the user's facial expressions and voice and provides feedback to the operation of the entire system. Emotional data is analyzed and adjustments are made to improve the user experience. This data is used for UI design and product recommendations. The input is user emotional data, and the output is feedback and improvement suggestions for the system.

[0352] Step 8:

[0353] Recommendations are displayed based on the user's emotional data. The emotion engine recommends appropriate products and services based on the recognized emotion, thereby improving the user experience. The input is the recognized emotional data, and the output is a list of recommended products.

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

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

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

[0357] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0370] The present invention is an application development support system that utilizes generative AI, which automatically generates most of the program, and then has humans test and refine it to efficiently create high-quality applications. The following describes in detail the embodiments of the present invention.

[0371] 1. Main components

[0372] This system mainly consists of the following components:

[0373] User: Enters application requirements and reviews / modifies the generated code.

[0374] Terminal: A device used by the user to perform operations, providing a UI for inputting requirements and checking and modifying code.

[0375] Server: Analyzes the requirements specifications, automatically generates program code using a generative AI model, and also generates and executes test code.

[0376] 2. System Operation Overview

[0377] The operation of this system will be specifically explained below.

[0378] User input of requirements

[0379] The user uses a terminal to input the application requirements in natural language. For example, they might input something like, "I want to create a task management app that allows users to add, edit, and delete tasks."

[0380] Submitting and analyzing requirements

[0381] The terminal sends the requirements entered by the user to the server, which analyzes the received requirements and extracts specific program requirements based on the generative AI model. At this stage, the necessary database structure, API endpoints, etc. are defined.

[0382] Automatic program generation

[0383] The server automatically generates back-end and front-end program code based on the extracted program requirements. Specifically, it generates database models and API endpoints for the back-end, and UI components for the front-end.

[0384] Generate and run test code

[0385] The server also generates corresponding test code for the generated program code and automatically runs the tests, running basic unit and integration tests to uncover early bugs.

[0386] Human review and correction

[0387] The user uses a terminal to check the generated program code and test results, and if necessary, modify or customize the code. This is also the stage where the user can add their own functions or fine-tune the UI.

[0388] Release preparation and deployment

[0389] Finally, the user prepares the release, which includes checking configuration files and deployment scripts, and then deploys the application to a server or cloud environment, making it live and available to users.

[0390] Example: Task management app

[0391] As an example, consider a simple task management app that allows users to add, edit, and delete tasks.

[0392] 1. The user enters the requirements specification using a terminal.

[0393] 2. The server parses the requirements and defines the database structure (e.g., task table) and API endpoints.

[0394] 3. The server uses the generative AI model to automatically generate back-end and front-end program code.

[0395] 4. The server also generates test code for unit tests and integration tests and runs them automatically.

[0396] 5. The user reviews the generated code and test results and corrects any deficiencies or errors.

[0397] 6. Once the checks and corrections are complete, the user prepares the release and deploys the application.

[0398] In this way, by utilizing generative AI, the present invention provides an environment in which even beginners with no programming knowledge can easily develop high-quality applications. It is also effective in alleviating the declining labor force and labor shortages.

[0399] The processing flow will be explained below.

[0400] Step 1:

[0401] The user uses the device to enter the application requirements. Specifically, the user enters the requirements in natural language into a form or text area on the device, such as "I want to create a task management app. I want to provide a function that allows users to add, edit, and delete tasks." When the user has completed the input, they click the submit button.

[0402] Step 2:

[0403] The terminal sends the user's required specifications to the server. Specifically, it sends the required specifications to the server as an HTTP POST request. At this time, the terminal converts the input data into an appropriate format and performs error checks before sending it to the server.

[0404] Step 3:

[0405] The server analyzes the requirements received. Specifically, it uses natural language processing technology to convert the input requirements into program requirements. For example, from the requirements for a "task management app," it extracts that a "task table" and "CRUD operations" are required.

[0406] Step 4:

[0407] The server uses the generative AI model to automatically generate specific program code. For example, back-end code using Django and front-end code using React are generated. The server stores this code in an internal database.

[0408] Step 5:

[0409] The server also automatically generates and executes test code. Specifically, it generates unit test code and integration test code and executes the tests on the generated program code. The test results are managed within the server and used for subsequent processing.

[0410] Step 6:

[0411] The server compiles the test results and sends them to the device. Specifically, it generates a detailed report including the success / failure results of the test and an error log, and sends it to the device. This allows the user to check the quality of the generated code.

[0412] Step 7:

[0413] The user uses the terminal to check the generated program code and test results, specifically, opens the code using an IDE or text editor on the terminal, reviews the test results, and modifies or customizes the code as needed.

[0414] Step 8:

[0415] The user performs final testing and fixes, specifically testing the modified and customized code again to ensure all test cases pass, and repeating this process until the problem is resolved.

[0416] Step 9:

[0417] The user prepares for release and deploys the application. Specifically, the user checks the configuration files and deployment scripts, and executes the deployment command from the terminal to the server or cloud environment. If the deployment is successful, the application actually starts running.

[0418] Through each of these steps, the system of the present invention enables even beginners with no programming knowledge to develop high-quality applications quickly and efficiently.

[0419] Example 1

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

[0421] Modern application development requires advanced programming knowledge, making it difficult for beginners and non-technical people to develop high-quality applications. To improve development efficiency, it is necessary to not only automatically generate code, but also to integrate a series of tasks, such as automatic testing and deployment. Furthermore, the declining workforce and labor shortages are becoming more serious problems. A system that can solve these issues and enable efficient, high-quality application development is needed.

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

[0423] In this invention, the server includes: a means for a user to input application requirements using a terminal; a means for the terminal to transmit the user's requirements to the server; a means for the server to analyze the received requirements and extract specific program requirements based on a generative AI model using natural language processing technology; a means for the server to automatically generate back-end code and front-end code based on the extracted program requirements; a means for the server to generate test code for the automatically generated program code and automatically perform unit tests and integration tests based on the test code; a means for the user to check the generated program code and test results using a terminal and make modifications and customizations as necessary; and a means for the user to perform final testing and release preparation and deploy to a server or cloud environment. This enables even users with little programming knowledge to efficiently develop advanced applications. It also provides an innovative development environment that can address the declining workforce and labor shortages.

[0424] "User" refers to a person or organization whose role is to input application requirements specifications and to review and modify the generated program code and test results.

[0425] A "terminal" is a device that is operated by the user and provides a user interface for inputting required specifications and checking and modifying code.

[0426] "Server" refers to a computer system that has the ability to analyze user requirements and automatically generate program code using a generative AI model, as well as the ability to generate and execute test code.

[0427] "Requirements specifications" refers to information written in natural language by a user describing the functions and characteristics required for an application.

[0428] "Natural language processing technology" refers to technology for processing and analyzing human language using a computer.

[0429] A "generative AI model" refers to an artificial intelligence model that automatically generates program code and requirements based on provided data.

[0430] "Program requirements" refers to elements for defining the structure and functions of a specific program based on the analyzed requirements specifications.

[0431] "Back-end code" refers to the program code that performs the server-side processing of an application.

[0432] "Front-end code" refers to the program code that builds the user interface and manages the user's interaction with the application.

[0433] "Test code" refers to code for verifying the operation of generated program code.

[0434] A "unit test" refers to a test that verifies the operation of an individual program unit.

[0435] "Integration testing" refers to testing that verifies the operation of multiple program units combined together.

[0436] A "cloud environment" refers to an environment for using server resources and applications provided via the Internet.

[0437] This invention relates to an application development support system that utilizes a generative AI model. This system automatically generates program code and test code based on user-provided requirements, providing a method for efficiently developing high-quality applications.

[0438] Main components

[0439] This system mainly consists of the following components:

[0440] User: Enters application requirements and reviews / modifies the generated code.

[0441] Terminal: A device used by the user to perform operations, providing a user interface for inputting requirements and checking and modifying code.

[0442] Server: Analyzes the requirements specifications, automatically generates program code using a generative AI model, and generates and executes test code.

[0443] System Operation Overview

[0444] The operation of the system proceeds as follows.

[0445] Input of required specifications

[0446] The user inputs the application requirements in natural language using a terminal, for example, by entering the following prompt sentence:

[0447] I want to create a task management app that allows users to add, edit, and delete tasks.

[0448] Submitting and analyzing requirements

[0449] The terminal sends the requirements entered by the user to the server. The server analyzes the received requirements using natural language processing technology and extracts specific program requirements based on a generative AI model. Specifically, it extracts keywords and structures using natural language processing libraries such as SpaCy and NLTK, and inputs them into a generative AI model (e.g., GPT-3) to generate program requirements.

[0450] Automatic program generation

[0451] The server automatically generates program code based on the analysis results. The back-end code is primarily generated using Python and Flask, while the front-end code is generated using frameworks such as React. The database structure and API endpoints are also defined at the same time.

[0452] Generate and run test code

[0453] The server automatically generates test code for the generated program code, and uses test frameworks such as PyTest and Jest to run unit tests and integration tests and obtain test results.

[0454] Check and fix the code

[0455] The user can then use a terminal to review the generated program code and test results, modifying or customizing the code as needed. During this step, real-time code validation and suggestions are provided using a code editor such as VSCode.

[0456] Release preparation and deployment

[0457] Finally, the user checks the generated program configuration files and deployment scripts and deploys the application to a cloud environment (e.g., AWS, Azure, GCP), making the application available for use.

[0458] Specific examples

[0459] Here is a simple example of a task management app. The user enters the following prompt from the terminal:

[0460] I want to create a task management app that allows users to add, edit, and delete tasks.

[0461] Based on the above input, the server analyzes the requirements and defines the database structure for the task table and the necessary API endpoints. It then uses a generative AI model to automatically generate backend code (using Python and Flask) and frontend code (using React), and creates and runs test code for each. The user can then review and modify the generated code, and finally deploy it to a cloud environment. This series of processes enables the efficient development of a high-quality task management app.

[0462] This system allows even users with little programming knowledge to efficiently develop advanced applications, providing an effective development environment to address the declining workforce and labor shortages.

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

[0464] Step 1:

[0465] The user uses a device to input the application requirements. The user provides input in natural language into a form on the device. A specific example of input is provided: "I want to create a task management app. I want to provide functionality that allows users to add, edit, and delete tasks." This input prompt becomes the data for the next process.

[0466] Step 2:

[0467] The terminal sends the requirements entered by the user to the server. When the send button on the terminal is clicked, the requirements are sent to the server via the network. At this time, the entered natural language text is sent to the server endpoint as a POST request (input: natural language requirements, output: requirements passed to the server).

[0468] Step 3:

[0469] The server analyzes the received requirements using natural language processing techniques. For example, the server uses libraries such as SpaCy or NLTK to tokenize the text and extract key keywords and grammatical structures (input: natural language requirements, output: keywords and structured data).

[0470] Step 4:

[0471] The server provides prompts to the generative AI model based on the analysis results and extracts specific program requirements. The server generates program requirements from the requirements specification using, for example, GPT-3. These requirements include the database structure and API endpoints (input: analysis results, output: program requirements).

[0472] Step 5:

[0473] The server automatically generates back-end and front-end code based on the extracted program requirements. The back-end code is generated using Python and Flask, and the front-end code is generated using React (input: program requirements, output: automatically generated code).

[0474] Step 6:

[0475] The server generates test code for the generated program code and automatically executes unit tests and integration tests based on the generated code. For example, it generates test code using a test framework such as PyTest or Jest and automatically executes the tests (input: generated program code, output: test results).

[0476] Step 7:

[0477] The user can view the generated program code and test results using a terminal. A code editor (e.g., VSCode) or browser is displayed on the terminal, where the user can modify and customize the code (input: generated code and test results, output: modified code).

[0478] Step 8:

[0479] The user performs final testing and release preparation, then deploys to a server or cloud environment. The user checks the configuration files and deployment scripts and executes the deployment to the appropriate environment (input: final code and configuration files, output: deployed application).

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

[0481] (Application example 1)

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

[0483] Demand for video streaming services is increasing in modern society. However, operating a video streaming service requires advanced technical skills and significant resources, making it difficult for individuals and small and medium-sized enterprises to easily launch and operate a service. Furthermore, the complex development process and numerous testing and deployment procedures make it difficult to provide services quickly. Furthermore, while appropriate testing and user interface design are required to ensure code quality, there is a lack of automated methods for these processes.

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

[0485] In this invention, the server includes: a means for a user to input application requirements using a terminal; a means for the server to analyze the received requirements and extract specific program requirements based on a generative AI model; a means for the server to automatically generate program code based on the extracted program requirements; a means for the server to generate test code for the automatically generated program code and automatically run tests based on the test code; a means for the user to review the generated program code and test results and modify and customize it as necessary; a means for the user to perform final testing and release preparation and deploy it to a server or cloud environment; and a means for automatically generating functions for a video streaming service, allowing users to upload videos and for viewers to comment. This allows users to easily start and operate a video streaming service without advanced technical knowledge. Furthermore, automatic code generation and testing enables rapid and high-quality service provision.

[0486] "User" refers to a person or organization that inputs application requirements specifications, and reviews, modifies, customizes, and prepares the generated program code and test results for release.

[0487] A "terminal" is a device that a user operates and provides a user interface for inputting required specifications and checking and modifying code.

[0488] "Requirements specifications" are requirements regarding the functions and features of an application that are input by the user in natural language.

[0489] A "server" is a device or system that analyzes requirements received from a user, automatically generates program code and test code using a generative AI model, and then automatically executes tests based on this code.

[0490] A "generative AI model" is an artificial intelligence model that extracts specific program requirements based on required specifications and automatically generates corresponding program code.

[0491] "Program requirements" refer to the specific program components and functions extracted by the generative AI model.

[0492] "Program Code" means the back-end and front-end source code automatically generated by the Server.

[0493] "Test code" refers to code generated to check the basic operation of the generated program code.

[0494] "Deployment" refers to the procedure in which a user places the final application on a server or cloud environment and makes it available for use by users.

[0495] A "video streaming service" is a service that allows users to distribute videos over the Internet and allows viewers to watch those videos in real time or on demand.

[0496] The present invention provides an application development support system using a generative AI model, which supports automatic program generation and video streaming service operation. The following describes in detail an embodiment of the present invention.

[0497] Main components

[0498] The system mainly consists of the following components:

[0499] User: Enters application requirements and checks and modifies the generated program code and test results.

[0500] Terminal: A device used by the user to perform operations, providing a user interface for inputting requirements and checking and modifying code.

[0501] Server: Analyzes requirements specifications, automatically generates program code and test code using a generative AI model, and automatically executes tests based on this code.

[0502] System Operation Overview

[0503] Input of required specifications

[0504] The user uses a terminal to input the required specifications for the video streaming service in natural language. For example, they might input something like, "I want to create a video streaming service that allows users to upload videos and provides a function that allows viewers to comment."

[0505] Analysis of requirements specifications and extraction of program requirements

[0506] The server analyzes the received requirements and extracts specific program requirements based on the generative AI model, which defines the necessary database structure, API endpoints, etc.

[0507] Automatic generation of program code

[0508] The server automatically generates program code based on the extracted program requirements. For example, database models and API endpoints are defined on the backend, and UI components are automatically generated on the frontend. Specific features for video streaming services (such as video uploads and viewer comment functions) are also automatically generated.

[0509] Test code generation and automatic execution

[0510] The server then generates test code for the generated program code and automatically executes the tests, conducting unit tests and integration tests to identify any early defects.

[0511] Check and fix

[0512] The user uses a terminal to check the generated program code and test results, and can modify or customize the code as needed. This is also the stage where users can add their own functions or fine-tune the UI.

[0513] Release preparation and deployment

[0514] Finally, the user prepares the release and deploys it to a server or cloud environment, which then provides the actual video streaming service.

[0515] Hardware and software used

[0516] Hardware: Smartphone, PC (user device)

[0517] Software: Python, generative AI models, general-purpose frameworks, streaming servers (e.g., NGINX, Wowza)

[0518] Specific examples

[0519] Here is an example of a simple prompt:

[0520] "Generate application code for a video streaming service. It should allow users to upload videos and viewers to comment. It should also include a user management system."

[0521] Based on this prompt, the generative AI model automatically generates application code, which the user can review and modify before finally deploying.

[0522] This invention allows users to easily launch and operate a video streaming service without advanced technical knowledge, and the automatic code generation and testing enables rapid and high-quality service provision.

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

[0524] Step 1:

[0525] A user uses a device to input the requirements for a video streaming service in natural language. For example, they might input, "I want to create a video streaming service that allows users to upload videos and viewers to comment." This requirement becomes the input for the system.

[0526] Step 2:

[0527] The terminal sends the requirements input by the user to the server. At this stage, the requirements are sent in natural language as input data. The server receives them and prepares to start analysis.

[0528] Step 3:

[0529] The server analyzes the received requirements and extracts specific program requirements based on a generative AI model. The generative AI model analyzes the natural language requirements, identifies the necessary database structure and API endpoints, and outputs the program requirements. Specific operations include text data analysis and natural language processing.

[0530] Step 4:

[0531] Based on the program requirements extracted by the server, back-end and front-end program code is automatically generated. The generative AI model generates code based on the input program requirements and outputs the results. Specifically, the database model and API are defined on the back-end, and user interface components are generated on the front-end.

[0532] Step 5:

[0533] The server generates test code corresponding to the automatically generated program code and automatically executes the tests. Based on the input program code, it generates the necessary unit tests and integration tests and executes them. A report of the test results is obtained as output. Specifically, it performs static analysis of the code and executes dynamic tests.

[0534] Step 6:

[0535] The user uses a terminal to check the generated program code and test results. The inputs are the test result report and the generated program code, and the user can modify or customize it as needed. Specifically, modifications are made using a code editor or debugging tool.

[0536] Step 7:

[0537] The user performs final testing and release preparation, then deploys to a server or cloud environment. The input is the modified program code and configuration files, and the deployment is based on these. The output is a working video streaming service. Specific operations include running the deployment script and applying the server settings.

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

[0539] The present invention is an application development support system that utilizes generative AI and incorporates an emotion engine that recognizes user emotions. High-quality applications are efficiently created by automatically generating the majority of the program, followed by human testing and refinement. The following describes in detail the embodiments of the present invention.

[0540] 1. Main components

[0541] This system mainly consists of the following components:

[0542] User: Enters application requirements and reviews / modifies the generated code.

[0543] Terminal: A device used by the user to perform operations, providing a UI for inputting requirements and checking and modifying code.

[0544] Server: Analyzes the requirements specifications, automatically generates program code using a generative AI model, and also generates and executes test code.

[0545] Emotion engine: Recognizes user emotions and provides feedback to the overall system behavior.

[0546] 2. System Operation Overview

[0547] The operation of this system will be specifically explained below.

[0548] User input of requirements

[0549] The user uses a device to input the application requirements in natural language. For example, they might input something like, "I want to create a task management app. It should provide functions that allow users to add, edit, and delete tasks." At this time, the emotion engine recognizes and records the user's emotions from facial expressions, voice, and other factors.

[0550] Submitting and analyzing requirements

[0551] The device sends the requirements entered by the user to the server, which analyzes the received requirements and extracts specific program requirements based on the generative AI model. At this stage, the user's emotional data provided by the emotion engine is also reflected in the analysis results.

[0552] Automatic program generation

[0553] The server automatically generates back-end and front-end program code based on the extracted program requirements. For example, database models and API endpoints are generated on the back-end, and UI components are generated on the front-end. The UI design and color may also be adjusted based on the user's emotions.

[0554] Generate and run test code

[0555] The server also generates corresponding test code for the generated program code and automatically executes the tests. This executes basic unit tests and integration tests to identify early-stage bugs. The test results are managed within the server and used for subsequent processing.

[0556] Human review and correction

[0557] The user uses the device to check the generated program code and test results. Specifically, they open the code using the device's IDE or text editor and review the test results. They can then modify or customize the code as needed. The emotion engine also collects user emotion data during the project and provides feedback and suggestions for improvement.

[0558] Release preparation and deployment

[0559] Finally, the user prepares the release, which includes checking configuration files and deployment scripts. The user then deploys the application to a server or cloud environment. If the deployment is successful, the application goes live.

[0560] Example: Task management app

[0561] As an example, consider a simple task management app that allows users to add, edit, and delete tasks.

[0562] 1. The user inputs the required specifications using a terminal. At this time, the emotion engine analyzes the user's facial expressions and voice and records emotional data.

[0563] 2. The server analyzes the requirements and defines the database structure (e.g., task table) and API endpoints. Emotion data is also used for analysis.

[0564] 3. The server uses the generative AI model to automatically generate back-end and front-end program code. The UI design may be adjusted based on the emotion data.

[0565] 4. The server also generates test code for unit tests and integration tests and runs them automatically.

[0566] 5. The user reviews the generated code and test results, and fixes any deficiencies or errors. The emotion engine provides user feedback.

[0567] 6. Once the checks and corrections are complete, the user prepares the release and deploys the application.

[0568] In this way, by utilizing generative AI and an emotion engine, this invention enables even beginners with no programming knowledge to quickly and efficiently develop high-quality applications. In addition, by taking user emotions into consideration, it is possible to provide more intuitive and easy-to-use applications.

[0569] The processing flow will be explained below.

[0570] Step 1:

[0571] The user uses the device to input the application requirements. For example, the user might enter a requirement in natural language into a form or text area on the device, such as "I want to create a task management app. It should provide the ability for users to add, edit, and delete tasks." At this time, the emotion engine recognizes the user's face and analyzes their voice, and records their emotional data.

[0572] Step 2:

[0573] The device sends the user's requirements and emotion data to the server. Specifically, it sends the requirements entered using an HTTP POST request and the data collected by the emotion engine to the server.

[0574] Step 3:

[0575] The server analyzes the received requirements and emotion data. It then uses natural language processing technology to convert the requirements into program requirements and corrects the analysis results based on the emotion data. For example, if the user is nervous, it generates suggestions to simplify the interface to improve the user experience.

[0576] Step 4:

[0577] The server uses the generative AI model to automatically generate specific program code. For example, it generates back-end code using Django and front-end code using React. During this process, the UI color and design may change depending on the user's emotions.

[0578] Step 5:

[0579] The server also automatically generates test code and executes the tests. Specifically, it generates unit test code and integration test code and executes the tests on the generated application code. The test results are managed within the server and used for subsequent processing.

[0580] Step 6:

[0581] The server compiles the test results and sends them to the device. A detailed report is generated and sent to the device, including test success / failure results and error logs. The user can then check the quality of the generated code based on this.

[0582] Step 7:

[0583] The user uses the terminal to view the generated program code and test results, opens the code using an IDE or text editor on the terminal, reviews the test results, and modifies and customizes the code as needed.

[0584] Step 8:

[0585] The user performs final testing and fixes. The fixed and customized code is retested to ensure all test cases pass. This process is repeated until the issue is resolved.

[0586] Step 9:

[0587] The user prepares for release and deploys the application. They check the configuration files and deployment scripts, and execute the deployment command from the terminal to the server or cloud environment. If the deployment is successful, the application actually starts running.

[0588] Through these steps, the system of the present invention enables even beginners with no programming knowledge to quickly and efficiently develop high-quality applications. Furthermore, the emotion engine provides customization according to the user's emotions, improving the user experience.

[0589] Example 2

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

[0591] In the current application development process, automatic generation and testing of program code requires specialized knowledge, making it difficult for beginners and non-experts to develop efficiently.In addition, while the importance of interfaces and feedback that take user emotions into account is increasing, there is no system that can automatically reflect this.

[0592] The specification processing by the specification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes: means for a user to input application requirement specifications using a terminal; means for the server to analyze the received requirement specifications and extract specific program requirements based on a generative AI model; means for the server to automatically generate program code based on the extracted program requirements; means for the server to generate test code for the automatically generated program code and automatically execute tests based on the test code; means for a user to check the generated program code and test results and modify and customize it as necessary; means for a user to perform final testing and release preparation and deploy it to a server or cloud environment; and means for collecting and analyzing user emotion data using an emotion engine and providing feedback to the operation of the entire system. This allows even users without programming knowledge to efficiently develop high-quality applications, and enables interfaces and feedback that take user emotions into consideration to be automatically reflected.

[0593] A "terminal" is a device that a user operates, and is a device that allows text input and screen operation.

[0594] A "server" is a computer system that receives requests over a network and performs the specified processing.

[0595] "Requirements specifications" are documents or inputs that describe the specific requirements, such as the functions and performance, of the application that the user wants to develop.

[0596] A "generative AI model" is an artificial intelligence model used to analyze received requirements specifications and automatically generate specific program requirements.

[0597] "Program code" is code that describes specific instructions for a computer to execute.

[0598] "Test code" is code created to verify the accuracy and performance of generated program code.

[0599] "Test results" are the output and verification results obtained when test code is executed, and indicate the soundness of the program.

[0600] The "emotion engine" is a component that recognizes emotions from the user's facial expressions and voice, and provides feedback to the operation of the entire system.

[0601] "Deployment" is the process of placing an application that has been developed on a server or in a cloud environment and running it.

[0602] "Back-end code" is program code that runs on the server side and is responsible for managing databases and logic.

[0603] "Front-end code" is the program code that manages the interface with which the user directly interacts and the user interactions.

[0604] A "unit test" is a test that verifies the correctness of individual parts or components of a program.

[0605] "Integration testing" is testing that verifies whether multiple components or the entire system work together correctly.

[0606] "Natural language" refers to the language used by humans on a daily basis, and refers to the terms used in writing and conversation, rather than a specific programming language.

[0607] This invention is an application development support system that utilizes a generative AI model and an emotion engine. This system automatically generates program code based on user requirements and reflects the user's emotions as feedback in the overall system operation, thereby achieving efficient and high-quality application development.

[0608] System configuration

[0609] This system mainly consists of the following components:

[0610] Terminal: A device operated by the user that provides an interface for inputting required specifications and checking and correcting the generated code. The terminal is equipped with an emotion engine that recognizes emotions from the user's facial expressions and voice, and records the data.

[0611] Server: Analyzes the requirements specifications sent by the user and extracts specific program requirements using a generative AI model. It also has the ability to automatically generate program code and test code based on the extracted requirements and execute the tests.

[0612] Emotion engine: Collects and analyzes user emotional data and provides feedback to the system based on this.

[0613] Operation overview

[0614] The operation of this system will be specifically outlined below.

[0615] The user inputs the requirements for the application they wish to develop in natural language from their device. For example, they might input something like, "I want to create a task management app. It will provide a function that allows users to add, edit, and delete tasks." The device is equipped with an emotion engine that analyzes the user's facial expressions and voice to collect emotional data, which is then sent to the server along with the requirements.

[0616] When the server receives the requirements, it analyzes them using a generative AI model (e.g., GPT-4) to extract specific program requirements. The results of this analysis also reflect the user's emotional data. For example, if the system determines that the user has time to spare, it can suggest more advanced features to the user.

[0617] The server then automatically generates backend (e.g., Node.js, Express, MongoDB) and frontend (e.g., React, Bootstrap) program code based on the extracted program requirements. Depending on the emotion data, the UI design and color scheme may also be adjusted.

[0618] The server then automatically generates unit and integration test code for the generated program code and immediately runs the tests. The test results are managed within the server, and initial bugs and issues can be identified based on the results.

[0619] The user can then use their device to check the generated program code and test results, and make any necessary modifications or customizations. During this process, the emotion engine analyzes the user's emotional data and provides appropriate feedback.

[0620] Finally, users prepare for release, check the configuration files and deployment scripts, and then deploy the application to a server or cloud environment to run it. Through this process, users can develop efficient and high-quality applications quickly.

[0621] Specific examples

[0622] As a specific example, a scene in which a user inputs the following prompt sentence will be shown.

[0623] I want to create a task management app that allows users to add, edit, and delete tasks.

[0624] Based on these requirements, the server analyzes them using a generative AI model and automatically generates the necessary program code and test code. The emotion engine detects the user's sense of security and stress, and provides feedback to adjust the UI and suggest improvements. This allows users to efficiently develop task management apps with intuitive and easy-to-use interfaces.

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

[0626] Step 1: Enter requirements

[0627] The user uses a device to input the application requirements in natural language. Specifically, they enter "I want to create a task management app. I want to provide a function that allows users to add, edit, and delete tasks" into an input field on the device's UI. At this time, the emotion engine analyzes the user's facial expressions and voice and collects emotional data. The inputs are the requirements and emotional data, which are converted into a data format and sent to the server as output.

[0628] Step 2: Submit your requirements

[0629] The device sends the request specifications and emotion data entered by the user to the server. Specifically, it uses a REST API or WebSocket to send a request including the request specifications and emotion data. The request specifications and emotion data are used as input, and the server receives them as output.

[0630] Step 3: Analyze requirements

[0631] The server analyzes the received requirements and uses a generative AI model (e.g., GPT-4) to extract specific program requirements. Emotional data is also used in the analysis, taking into account the user's emotions. The input is the requirements and emotional data, and the output is defined as program requirements.

[0632] Step 4: Automatic program generation

[0633] The server automatically generates program code based on the extracted program requirements. Using a generative AI model, back-end and front-end code is generated. For example, database models and API endpoints are generated for the back-end, and UI components are generated for the front-end. The program requirements are used as input, and the generated program code is obtained as output.

[0634] Step 5: Generate and run test code

[0635] The server automatically generates test code for the generated program code and executes the tests, including unit tests and integration tests. The input is the generated program code, and the test code is generated and executed, resulting in the test results as output.

[0636] Step 6: Human review and correction

[0637] The user uses the terminal to review the generated program code and test results. Specifically, they open the code in the terminal's IDE or text editor and make modifications and customizations as needed. The emotion engine provides feedback based on the user's progress. The input is the generated code and test results, and the output is the modified code and comments.

[0638] Step 7: Release preparation and deployment

[0639] The user prepares for release. After checking the configuration files and deployment scripts and completing the final checks, the user deploys the application to the server or cloud environment. Specifically, the deployment is performed by executing a command. The input is the finalized program code, and the output is a working application.

[0640] (Application example 2)

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

[0642] Conventional application development support systems have difficulty providing interfaces and functions that take user emotions into account, limiting the improvement of user experience. Furthermore, they are unable to intuitively recommend products based on user emotions in virtual stores, resulting in a less satisfying shopping experience.

[0643] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: means for a user to input application requirement specifications using a terminal; means for analyzing the received requirement specifications and extracting specific program requirements based on a generative AI model; means for automatically generating program code based on the extracted program requirements; means for generating test code for the automatically generated program code and automatically running tests based on the generated test code; means for checking the generated program code and test results, and modifying and customizing it as necessary; means for performing final testing and preparing for release, and deploying it to a server or cloud environment; means for recognizing user emotions using an emotion engine and providing feedback to the operation of the entire system; and means for displaying recommended products based on the user's emotion data. This enables customization based on the user's emotions, providing an intuitive and satisfying shopping experience in a virtual store.

[0644] "User" is the individual or end user who inputs the application requirements and reviews and modifies the generated code.

[0645] A "terminal" is a device that is operated by a user and provides a user interface for inputting required specifications and checking and correcting code.

[0646] A "server" is a computer system that analyzes the received requirements specifications, automatically generates program code and test code based on a generative AI model, and oversees processing on the system.

[0647] A "generative AI model" is an artificial intelligence model that extracts specific program requirements based on the requirements specifications entered by the user and automatically generates code.

[0648] "Program requirements" are specifications for specific functions and processes extracted based on the requirements analyzed by the generative AI model.

[0649] "Program code" refers to source code that is automatically generated by a generative AI model to realize various functions and processes.

[0650] "Test code" is code used to verify the operation of automatically generated program code.

[0651] The "emotion engine" is an engine that recognizes emotions from the user's facial expressions and voice and provides feedback to the system's operation.

[0652] "Recommended products" are products or services that are suggested to a user based on the user's emotional data recognized using the emotion engine.

[0653] "Deployment" is a method of transferring developed program code to an environment where it can actually be used and arranging it so that it can run.

[0654] The system that realizes this application example consists of the following elements: The user uses a terminal to input the application requirements in natural language. For example, they might input something like, "I want to create a task management app. It should provide a function that allows users to add, edit, and delete tasks." At this time, the emotion engine recognizes and records the user's emotions from their facial expressions, voice, etc.

[0655] The server analyzes the received requirements and extracts specific program requirements based on a generative AI model. The server then automatically generates back-end code (e.g., Django) and front-end code (e.g., React) based on the extracted program requirements. The UI design and color may be adjusted depending on the user's emotions, providing a user-friendly interface.

[0656] Next, the server generates test code for the automatically generated program code and automatically executes the tests. At this stage, basic unit tests and integration tests are performed to identify early bugs. The test results are managed within the server and provided to users for review and correction.

[0657] Users can use their devices to check the generated program code and test results, and correct any deficiencies or errors. The emotion engine collects users' emotional data during the project and provides feedback and suggestions for improvements based on this data, allowing users to work intuitively.

[0658] Finally, the user prepares the release, which includes checking configuration files and deployment scripts, after which the user deploys the application to a server or cloud environment and the application starts running.

[0659] A concrete example is a virtual store application. When a user launches the app, the camera captures the user's face and recognizes their emotions in real time. Based on the recognized emotional data, a list of recommended products is displayed. In this case, the hardware used is the smartphone's camera and microphone, and the software used is EmotionRecognizer and ProductRecommender.

[0660] Examples of prompts include:

[0661] "Please enter an image of the user smiling."

[0662] In this way, an application development support system that utilizes emotion recognition technology can be customized to suit the user's emotions, providing more intuitive and easy-to-use applications.

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

[0664] Step 1:

[0665] The user uses a device to input the application requirements in natural language. At this time, the user uses the interface on the device to input content such as, "I want to create a task management app. I want to provide a function that allows users to add, edit, and delete tasks." The user's requirements are sent as text data to the device as input. The device then sends this text data to the server.

[0666] Step 2:

[0667] The server analyzes the received requirements specification. It uses a generative AI model to extract specific program requirements from the text data. The input is the text data of the user's requirements specification, and the output is a list of specific program requirements. This analysis process uses natural language processing techniques to break down the text and extract key phrases and syntax.

[0668] Step 3:

[0669] The server automatically generates program code based on the extracted program requirements. The server uses a generative AI model to generate back-end code (using Django, for example) and front-end code (using React, for example). The output is a specific program code file.

[0670] Step 4:

[0671] The server generates corresponding test code for the automatically generated program code and automatically executes the tests based on this. The generated program code is used as input and goes through a transformation process to generate test code. The output is a log of the test results. The server systematically executes unit tests and integration tests to detect basic bugs and errors.

[0672] Step 5:

[0673] The user accesses the generated program code and test results using a terminal to view them. The user can view the code using an ID or text editor on the terminal and modify and customize it as needed. In this step, the user receives feedback generated based on the data analyzed by the emotion engine. The input is the generated code and test results, and the output is the modified and customized program code.

[0674] Step 6:

[0675] The user performs final testing and release preparation. Using a terminal, the user checks configuration files and deployment scripts and prepares the application for deployment to a server or cloud environment. The input is the finalized program code and configuration files, and the output is the deployed application, which is transferred to a working environment.

[0676] Step 7:

[0677] The emotion engine recognizes emotions from the user's facial expressions and voice and provides feedback to the operation of the entire system. Emotional data is analyzed and adjustments are made to improve the user experience. This data is used for UI design and product recommendations. The input is user emotional data, and the output is feedback and improvement suggestions for the system.

[0678] Step 8:

[0679] Recommendations are displayed based on the user's emotional data. The emotion engine recommends appropriate products and services based on the recognized emotion, thereby improving the user experience. The input is the recognized emotional data, and the output is a list of recommended products.

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

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

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

[0683] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0696] The present invention is an application development support system that utilizes generative AI, which automatically generates most of the program, and then has humans test and refine it to efficiently create high-quality applications. The following describes in detail the embodiments of the present invention.

[0697] 1. Main components

[0698] This system mainly consists of the following components:

[0699] User: Enters application requirements and reviews / modifies the generated code.

[0700] Terminal: A device used by the user to perform operations, providing a UI for inputting requirements and checking and modifying code.

[0701] Server: Analyzes the requirements specifications, automatically generates program code using a generative AI model, and also generates and executes test code.

[0702] 2. System Operation Overview

[0703] The operation of this system will be specifically explained below.

[0704] User input of requirements

[0705] The user uses a terminal to input the application requirements in natural language. For example, they might input something like, "I want to create a task management app that allows users to add, edit, and delete tasks."

[0706] Submitting and analyzing requirements

[0707] The terminal sends the requirements entered by the user to the server, which analyzes the received requirements and extracts specific program requirements based on the generative AI model. At this stage, the necessary database structure, API endpoints, etc. are defined.

[0708] Automatic program generation

[0709] The server automatically generates back-end and front-end program code based on the extracted program requirements. Specifically, it generates database models and API endpoints for the back-end, and UI components for the front-end.

[0710] Generate and run test code

[0711] The server also generates corresponding test code for the generated program code and automatically runs the tests, running basic unit and integration tests to uncover early bugs.

[0712] Human review and correction

[0713] The user uses a terminal to check the generated program code and test results, and if necessary, modify or customize the code. This is also the stage where the user can add their own functions or fine-tune the UI.

[0714] Release preparation and deployment

[0715] Finally, the user prepares the release, which includes checking configuration files and deployment scripts, and then deploys the application to a server or cloud environment, making it live and available to users.

[0716] Example: Task management app

[0717] As an example, consider a simple task management app that allows users to add, edit, and delete tasks.

[0718] 1. The user enters the requirements specification using a terminal.

[0719] 2. The server parses the requirements and defines the database structure (e.g., task table) and API endpoints.

[0720] 3. The server uses the generative AI model to automatically generate back-end and front-end program code.

[0721] 4. The server also generates test code for unit tests and integration tests and runs them automatically.

[0722] 5. The user reviews the generated code and test results and corrects any deficiencies or errors.

[0723] 6. Once the checks and corrections are complete, the user prepares the release and deploys the application.

[0724] In this way, by utilizing generative AI, the present invention provides an environment in which even beginners with no programming knowledge can easily develop high-quality applications. It is also effective in alleviating the declining labor force and labor shortages.

[0725] The processing flow will be explained below.

[0726] Step 1:

[0727] The user uses the device to enter the application requirements. Specifically, the user enters the requirements in natural language into a form or text area on the device, such as "I want to create a task management app. I want to provide a function that allows users to add, edit, and delete tasks." When the user has completed the input, they click the submit button.

[0728] Step 2:

[0729] The terminal sends the user's required specifications to the server. Specifically, it sends the required specifications to the server as an HTTP POST request. At this time, the terminal converts the input data into an appropriate format and performs error checks before sending it to the server.

[0730] Step 3:

[0731] The server analyzes the requirements received. Specifically, it uses natural language processing technology to convert the input requirements into program requirements. For example, from the requirements for a "task management app," it extracts that a "task table" and "CRUD operations" are required.

[0732] Step 4:

[0733] The server uses the generative AI model to automatically generate specific program code. For example, back-end code using Django and front-end code using React are generated. The server stores this code in an internal database.

[0734] Step 5:

[0735] The server also automatically generates and executes test code. Specifically, it generates unit test code and integration test code and executes the tests on the generated program code. The test results are managed within the server and used for subsequent processing.

[0736] Step 6:

[0737] The server compiles the test results and sends them to the device. Specifically, it generates a detailed report including the success / failure results of the test and an error log, and sends it to the device. This allows the user to check the quality of the generated code.

[0738] Step 7:

[0739] The user uses the terminal to check the generated program code and test results, specifically, opens the code using an IDE or text editor on the terminal, reviews the test results, and modifies or customizes the code as needed.

[0740] Step 8:

[0741] The user performs final testing and fixes, specifically testing the modified and customized code again to ensure all test cases pass, and repeating this process until the problem is resolved.

[0742] Step 9:

[0743] The user prepares for release and deploys the application. Specifically, the user checks the configuration files and deployment scripts, and executes the deployment command from the terminal to the server or cloud environment. If the deployment is successful, the application actually starts running.

[0744] Through each of these steps, the system of the present invention enables even beginners with no programming knowledge to develop high-quality applications quickly and efficiently.

[0745] Example 1

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

[0747] Modern application development requires advanced programming knowledge, making it difficult for beginners and non-technical people to develop high-quality applications. To improve development efficiency, it is necessary to not only automatically generate code, but also to integrate a series of tasks, such as automatic testing and deployment. Furthermore, the declining workforce and labor shortages are becoming more serious problems. A system that can solve these issues and enable efficient, high-quality application development is needed.

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

[0749] In this invention, the server includes: a means for a user to input application requirements using a terminal; a means for the terminal to transmit the user's requirements to the server; a means for the server to analyze the received requirements and extract specific program requirements based on a generative AI model using natural language processing technology; a means for the server to automatically generate back-end code and front-end code based on the extracted program requirements; a means for the server to generate test code for the automatically generated program code and automatically perform unit tests and integration tests based on the test code; a means for the user to check the generated program code and test results using a terminal and make modifications and customizations as necessary; and a means for the user to perform final testing and release preparation and deploy to a server or cloud environment. This enables even users with little programming knowledge to efficiently develop advanced applications. It also provides an innovative development environment that can address the declining workforce and labor shortages.

[0750] "User" refers to a person or organization whose role is to input application requirements specifications and to review and modify the generated program code and test results.

[0751] A "terminal" is a device that is operated by the user and provides a user interface for inputting required specifications and checking and modifying code.

[0752] "Server" refers to a computer system that has the ability to analyze user requirements and automatically generate program code using a generative AI model, as well as the ability to generate and execute test code.

[0753] "Requirements specifications" refers to information written in natural language by a user describing the functions and characteristics required for an application.

[0754] "Natural language processing technology" refers to technology for processing and analyzing human language using a computer.

[0755] A "generative AI model" refers to an artificial intelligence model that automatically generates program code and requirements based on provided data.

[0756] "Program requirements" refers to elements for defining the structure and functions of a specific program based on the analyzed requirements specifications.

[0757] "Back-end code" refers to the program code that performs the server-side processing of an application.

[0758] "Front-end code" refers to the program code that builds the user interface and manages the user's interaction with the application.

[0759] "Test code" refers to code for verifying the operation of generated program code.

[0760] A "unit test" refers to a test that verifies the operation of an individual program unit.

[0761] "Integration testing" refers to testing that verifies the operation of multiple program units combined together.

[0762] A "cloud environment" refers to an environment for using server resources and applications provided via the Internet.

[0763] This invention relates to an application development support system that utilizes a generative AI model. This system automatically generates program code and test code based on user-provided requirements, providing a method for efficiently developing high-quality applications.

[0764] Main components

[0765] This system mainly consists of the following components:

[0766] User: Enters application requirements and reviews / modifies the generated code.

[0767] Terminal: A device used by the user to perform operations, providing a user interface for inputting requirements and checking and modifying code.

[0768] Server: Analyzes the requirements specifications, automatically generates program code using a generative AI model, and generates and executes test code.

[0769] System Operation Overview

[0770] The operation of the system proceeds as follows.

[0771] Input of required specifications

[0772] The user inputs the application requirements in natural language using a terminal, for example, by entering the following prompt sentence:

[0773] I want to create a task management app that allows users to add, edit, and delete tasks.

[0774] Submitting and analyzing requirements

[0775] The terminal sends the requirements entered by the user to the server. The server analyzes the received requirements using natural language processing technology and extracts specific program requirements based on a generative AI model. Specifically, it extracts keywords and structures using natural language processing libraries such as SpaCy and NLTK, and inputs them into a generative AI model (e.g., GPT-3) to generate program requirements.

[0776] Automatic program generation

[0777] The server automatically generates program code based on the analysis results. The back-end code is primarily generated using Python and Flask, while the front-end code is generated using frameworks such as React. The database structure and API endpoints are also defined at the same time.

[0778] Generate and run test code

[0779] The server automatically generates test code for the generated program code, and uses test frameworks such as PyTest and Jest to run unit tests and integration tests and obtain test results.

[0780] Check and fix the code

[0781] The user can then use a terminal to review the generated program code and test results, modifying or customizing the code as needed. During this step, real-time code validation and suggestions are provided using a code editor such as VSCode.

[0782] Release preparation and deployment

[0783] Finally, the user checks the generated program configuration files and deployment scripts and deploys the application to a cloud environment (e.g., AWS, Azure, GCP), making the application available for use.

[0784] Specific examples

[0785] Here is a simple example of a task management app. The user enters the following prompt from the terminal:

[0786] I want to create a task management app that allows users to add, edit, and delete tasks.

[0787] Based on the above input, the server analyzes the requirements and defines the database structure for the task table and the necessary API endpoints. It then uses a generative AI model to automatically generate backend code (using Python and Flask) and frontend code (using React), and creates and runs test code for each. The user can then review and modify the generated code, and finally deploy it to a cloud environment. This series of processes enables the efficient development of a high-quality task management app.

[0788] This system allows even users with little programming knowledge to efficiently develop advanced applications, providing an effective development environment to address the declining workforce and labor shortages.

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

[0790] Step 1:

[0791] The user uses a device to input the application requirements. The user provides input in natural language into a form on the device. A specific example of input is provided: "I want to create a task management app. I want to provide functionality that allows users to add, edit, and delete tasks." This input prompt becomes the data for the next process.

[0792] Step 2:

[0793] The terminal sends the requirements entered by the user to the server. When the send button on the terminal is clicked, the requirements are sent to the server via the network. At this time, the entered natural language text is sent to the server endpoint as a POST request (input: natural language requirements, output: requirements passed to the server).

[0794] Step 3:

[0795] The server analyzes the received requirements using natural language processing techniques. For example, the server uses libraries such as SpaCy or NLTK to tokenize the text and extract key keywords and grammatical structures (input: natural language requirements, output: keywords and structured data).

[0796] Step 4:

[0797] The server provides prompts to the generative AI model based on the analysis results and extracts specific program requirements. The server generates program requirements from the requirements specification using, for example, GPT-3. These requirements include the database structure and API endpoints (input: analysis results, output: program requirements).

[0798] Step 5:

[0799] The server automatically generates back-end and front-end code based on the extracted program requirements. The back-end code is generated using Python and Flask, and the front-end code is generated using React (input: program requirements, output: automatically generated code).

[0800] Step 6:

[0801] The server generates test code for the generated program code and automatically executes unit tests and integration tests based on the generated code. For example, it generates test code using a test framework such as PyTest or Jest and automatically executes the tests (input: generated program code, output: test results).

[0802] Step 7:

[0803] The user can view the generated program code and test results using a terminal. A code editor (e.g., VSCode) or browser is displayed on the terminal, where the user can modify and customize the code (input: generated code and test results, output: modified code).

[0804] Step 8:

[0805] The user performs final testing and release preparation, then deploys to a server or cloud environment. The user checks the configuration files and deployment scripts and executes the deployment to the appropriate environment (input: final code and configuration files, output: deployed application).

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

[0807] (Application example 1)

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

[0809] Demand for video streaming services is increasing in modern society. However, operating a video streaming service requires advanced technical skills and significant resources, making it difficult for individuals and small and medium-sized enterprises to easily launch and operate a service. Furthermore, the complex development process and numerous testing and deployment procedures make it difficult to provide services quickly. Furthermore, while appropriate testing and user interface design are required to ensure code quality, there is a lack of automated methods for these processes.

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

[0811] In this invention, the server includes: a means for a user to input application requirements using a terminal; a means for the server to analyze the received requirements and extract specific program requirements based on a generative AI model; a means for the server to automatically generate program code based on the extracted program requirements; a means for the server to generate test code for the automatically generated program code and automatically run tests based on the test code; a means for the user to review the generated program code and test results and modify and customize it as necessary; a means for the user to perform final testing and release preparation and deploy it to a server or cloud environment; and a means for automatically generating functions for a video streaming service, allowing users to upload videos and for viewers to comment. This allows users to easily start and operate a video streaming service without advanced technical knowledge. Furthermore, automatic code generation and testing enables rapid and high-quality service provision.

[0812] "User" refers to a person or organization that inputs application requirements specifications, and reviews, modifies, customizes, and prepares the generated program code and test results for release.

[0813] A "terminal" is a device that a user operates and provides a user interface for inputting required specifications and checking and modifying code.

[0814] "Requirements specifications" are requirements regarding the functions and features of an application that are input by the user in natural language.

[0815] A "server" is a device or system that analyzes requirements received from a user, automatically generates program code and test code using a generative AI model, and then automatically executes tests based on this code.

[0816] A "generative AI model" is an artificial intelligence model that extracts specific program requirements based on required specifications and automatically generates corresponding program code.

[0817] "Program requirements" refer to the specific program components and functions extracted by the generative AI model.

[0818] "Program Code" means the back-end and front-end source code automatically generated by the Server.

[0819] "Test code" refers to code generated to check the basic operation of the generated program code.

[0820] "Deployment" refers to the procedure in which a user places the final application on a server or cloud environment and makes it available for use by users.

[0821] A "video streaming service" is a service that allows users to distribute videos over the Internet and allows viewers to watch those videos in real time or on demand.

[0822] The present invention provides an application development support system using a generative AI model, which supports automatic program generation and video streaming service operation. The following describes in detail an embodiment of the present invention.

[0823] Main components

[0824] The system mainly consists of the following components:

[0825] User: Enters application requirements and checks and modifies the generated program code and test results.

[0826] Terminal: A device used by the user to perform operations, providing a user interface for inputting requirements and checking and modifying code.

[0827] Server: Analyzes requirements specifications, automatically generates program code and test code using a generative AI model, and automatically executes tests based on this code.

[0828] System Operation Overview

[0829] Input of required specifications

[0830] The user uses a terminal to input the required specifications for the video streaming service in natural language. For example, they might input something like, "I want to create a video streaming service that allows users to upload videos and provides a function that allows viewers to comment."

[0831] Analysis of requirements specifications and extraction of program requirements

[0832] The server analyzes the received requirements and extracts specific program requirements based on the generative AI model, which defines the necessary database structure, API endpoints, etc.

[0833] Automatic generation of program code

[0834] The server automatically generates program code based on the extracted program requirements. For example, database models and API endpoints are defined on the backend, and UI components are automatically generated on the frontend. Specific features for video streaming services (such as video uploads and viewer comment functions) are also automatically generated.

[0835] Test code generation and automatic execution

[0836] The server then generates test code for the generated program code and automatically executes the tests, conducting unit tests and integration tests to identify any early defects.

[0837] Check and fix

[0838] The user uses a terminal to check the generated program code and test results, and can modify or customize the code as needed. This is also the stage where users can add their own functions or fine-tune the UI.

[0839] Release preparation and deployment

[0840] Finally, the user prepares the release and deploys it to a server or cloud environment, which then provides the actual video streaming service.

[0841] Hardware and software used

[0842] Hardware: Smartphone, PC (user device)

[0843] Software: Python, generative AI models, general-purpose frameworks, streaming servers (e.g., NGINX, Wowza)

[0844] Specific examples

[0845] Here is an example of a simple prompt:

[0846] "Generate application code for a video streaming service. It should allow users to upload videos and viewers to comment. It should also include a user management system."

[0847] Based on this prompt, the generative AI model automatically generates application code, which the user can review and modify before finally deploying.

[0848] This invention allows users to easily launch and operate a video streaming service without advanced technical knowledge, and the automatic code generation and testing enables rapid and high-quality service provision.

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

[0850] Step 1:

[0851] A user uses a device to input the requirements for a video streaming service in natural language. For example, they might input, "I want to create a video streaming service that allows users to upload videos and viewers to comment." This requirement becomes the input for the system.

[0852] Step 2:

[0853] The terminal sends the requirements input by the user to the server. At this stage, the requirements are sent in natural language as input data. The server receives them and prepares to start analysis.

[0854] Step 3:

[0855] The server analyzes the received requirements and extracts specific program requirements based on a generative AI model. The generative AI model analyzes the natural language requirements, identifies the necessary database structure and API endpoints, and outputs the program requirements. Specific operations include text data analysis and natural language processing.

[0856] Step 4:

[0857] Based on the program requirements extracted by the server, back-end and front-end program code is automatically generated. The generative AI model generates code based on the input program requirements and outputs the results. Specifically, the database model and API are defined on the back-end, and user interface components are generated on the front-end.

[0858] Step 5:

[0859] The server generates test code corresponding to the automatically generated program code and automatically executes the tests. Based on the input program code, it generates the necessary unit tests and integration tests and executes them. A report of the test results is obtained as output. Specifically, it performs static analysis of the code and executes dynamic tests.

[0860] Step 6:

[0861] The user uses a terminal to check the generated program code and test results. The inputs are the test result report and the generated program code, and the user can modify or customize it as needed. Specifically, modifications are made using a code editor or debugging tool.

[0862] Step 7:

[0863] The user performs final testing and release preparation, then deploys to a server or cloud environment. The input is the modified program code and configuration files, and the deployment is based on these. The output is a working video streaming service. Specific operations include running the deployment script and applying the server settings.

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

[0865] The present invention is an application development support system that utilizes generative AI and incorporates an emotion engine that recognizes user emotions. High-quality applications are efficiently created by automatically generating the majority of the program, followed by human testing and refinement. The following describes in detail the embodiments of the present invention.

[0866] 1. Main components

[0867] This system mainly consists of the following components:

[0868] User: Enters application requirements and reviews / modifies the generated code.

[0869] Terminal: A device used by the user to perform operations, providing a UI for inputting requirements and checking and modifying code.

[0870] Server: Analyzes the requirements specifications, automatically generates program code using a generative AI model, and also generates and executes test code.

[0871] Emotion engine: Recognizes user emotions and provides feedback to the overall system behavior.

[0872] 2. System Operation Overview

[0873] The operation of this system will be specifically explained below.

[0874] User input of requirements

[0875] The user uses a device to input the application requirements in natural language. For example, they might input something like, "I want to create a task management app. It should provide functions that allow users to add, edit, and delete tasks." At this time, the emotion engine recognizes and records the user's emotions from facial expressions, voice, and other factors.

[0876] Submitting and analyzing requirements

[0877] The device sends the requirements entered by the user to the server, which analyzes the received requirements and extracts specific program requirements based on the generative AI model. At this stage, the user's emotional data provided by the emotion engine is also reflected in the analysis results.

[0878] Automatic program generation

[0879] The server automatically generates back-end and front-end program code based on the extracted program requirements. For example, database models and API endpoints are generated on the back-end, and UI components are generated on the front-end. The UI design and color may also be adjusted based on the user's emotions.

[0880] Generate and run test code

[0881] The server also generates corresponding test code for the generated program code and automatically executes the tests. This executes basic unit tests and integration tests to identify early-stage bugs. The test results are managed within the server and used for subsequent processing.

[0882] Human review and correction

[0883] The user uses the device to check the generated program code and test results. Specifically, they open the code using the device's IDE or text editor and review the test results. They can then modify or customize the code as needed. The emotion engine also collects user emotion data during the project and provides feedback and suggestions for improvement.

[0884] Release preparation and deployment

[0885] Finally, the user prepares the release, which includes checking configuration files and deployment scripts. The user then deploys the application to a server or cloud environment. If the deployment is successful, the application goes live.

[0886] Example: Task management app

[0887] As an example, consider a simple task management app that allows users to add, edit, and delete tasks.

[0888] 1. The user inputs the required specifications using a terminal. At this time, the emotion engine analyzes the user's facial expressions and voice and records emotional data.

[0889] 2. The server analyzes the requirements and defines the database structure (e.g., task table) and API endpoints. Emotion data is also used for analysis.

[0890] 3. The server uses the generative AI model to automatically generate back-end and front-end program code. The UI design may be adjusted based on the emotion data.

[0891] 4. The server also generates test code for unit tests and integration tests and runs them automatically.

[0892] 5. The user reviews the generated code and test results, and fixes any deficiencies or errors. The emotion engine provides user feedback.

[0893] 6. Once the checks and corrections are complete, the user prepares the release and deploys the application.

[0894] In this way, by utilizing generative AI and an emotion engine, this invention enables even beginners with no programming knowledge to quickly and efficiently develop high-quality applications. In addition, by taking user emotions into consideration, it is possible to provide more intuitive and easy-to-use applications.

[0895] The processing flow will be explained below.

[0896] Step 1:

[0897] The user uses the device to input the application requirements. For example, the user might enter a requirement in natural language into a form or text area on the device, such as "I want to create a task management app. It should provide the ability for users to add, edit, and delete tasks." At this time, the emotion engine recognizes the user's face and analyzes their voice, and records their emotional data.

[0898] Step 2:

[0899] The device sends the user's requirements and emotion data to the server. Specifically, it sends the requirements entered using an HTTP POST request and the data collected by the emotion engine to the server.

[0900] Step 3:

[0901] The server analyzes the received requirements and emotion data. It then uses natural language processing technology to convert the requirements into program requirements and corrects the analysis results based on the emotion data. For example, if the user is nervous, it generates suggestions to simplify the interface to improve the user experience.

[0902] Step 4:

[0903] The server uses the generative AI model to automatically generate specific program code. For example, it generates back-end code using Django and front-end code using React. During this process, the UI color and design may change depending on the user's emotions.

[0904] Step 5:

[0905] The server also automatically generates test code and executes the tests. Specifically, it generates unit test code and integration test code and executes the tests on the generated application code. The test results are managed within the server and used for subsequent processing.

[0906] Step 6:

[0907] The server compiles the test results and sends them to the device. A detailed report is generated and sent to the device, including test success / failure results and error logs. The user can then check the quality of the generated code based on this.

[0908] Step 7:

[0909] The user uses the terminal to view the generated program code and test results, opens the code using an IDE or text editor on the terminal, reviews the test results, and modifies and customizes the code as needed.

[0910] Step 8:

[0911] The user performs final testing and fixes. The fixed and customized code is retested to ensure all test cases pass. This process is repeated until the issue is resolved.

[0912] Step 9:

[0913] The user prepares for release and deploys the application. They check the configuration files and deployment scripts, and execute the deployment command from the terminal to the server or cloud environment. If the deployment is successful, the application actually starts running.

[0914] Through these steps, the system of the present invention enables even beginners with no programming knowledge to quickly and efficiently develop high-quality applications. Furthermore, the emotion engine provides customization according to the user's emotions, improving the user experience.

[0915] Example 2

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

[0917] In the current application development process, automatic generation and testing of program code requires specialized knowledge, making it difficult for beginners and non-experts to develop efficiently.In addition, while the importance of interfaces and feedback that take user emotions into account is increasing, there is no system that can automatically reflect this.

[0918] The specification processing by the specification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes: means for a user to input application requirement specifications using a terminal; means for the server to analyze the received requirement specifications and extract specific program requirements based on a generative AI model; means for the server to automatically generate program code based on the extracted program requirements; means for the server to generate test code for the automatically generated program code and automatically execute tests based on the test code; means for a user to check the generated program code and test results and modify and customize it as necessary; means for a user to perform final testing and release preparation and deploy it to a server or cloud environment; and means for collecting and analyzing user emotion data using an emotion engine and providing feedback to the operation of the entire system. This allows even users without programming knowledge to efficiently develop high-quality applications, and enables interfaces and feedback that take user emotions into consideration to be automatically reflected.

[0919] A "terminal" is a device that a user operates, and is a device that allows text input and screen operation.

[0920] A "server" is a computer system that receives requests over a network and performs the specified processing.

[0921] "Requirements specifications" are documents or inputs that describe the specific requirements, such as the functions and performance, of the application that the user wants to develop.

[0922] A "generative AI model" is an artificial intelligence model used to analyze received requirements specifications and automatically generate specific program requirements.

[0923] "Program code" is code that describes specific instructions for a computer to execute.

[0924] "Test code" is code created to verify the accuracy and performance of generated program code.

[0925] "Test results" are the output and verification results obtained when test code is executed, and indicate the soundness of the program.

[0926] The "emotion engine" is a component that recognizes emotions from the user's facial expressions and voice, and provides feedback to the operation of the entire system.

[0927] "Deployment" is the process of placing an application that has been developed on a server or in a cloud environment and running it.

[0928] "Back-end code" is program code that runs on the server side and is responsible for managing databases and logic.

[0929] "Front-end code" is the program code that manages the interface with which the user directly interacts and the user interactions.

[0930] A "unit test" is a test that verifies the correctness of individual parts or components of a program.

[0931] "Integration testing" is testing that verifies whether multiple components or the entire system work together correctly.

[0932] "Natural language" refers to the language used by humans on a daily basis, and refers to the terms used in writing and conversation, rather than a specific programming language.

[0933] This invention is an application development support system that utilizes a generative AI model and an emotion engine. This system automatically generates program code based on user requirements and reflects the user's emotions as feedback in the overall system operation, thereby achieving efficient and high-quality application development.

[0934] System configuration

[0935] This system mainly consists of the following components:

[0936] Terminal: A device operated by the user that provides an interface for inputting required specifications and checking and correcting the generated code. The terminal is equipped with an emotion engine that recognizes emotions from the user's facial expressions and voice, and records the data.

[0937] Server: Analyzes the requirements specifications sent by the user and extracts specific program requirements using a generative AI model. It also has the ability to automatically generate program code and test code based on the extracted requirements and execute the tests.

[0938] Emotion engine: Collects and analyzes user emotional data and provides feedback to the system based on this.

[0939] Operation overview

[0940] The operation of this system will be specifically outlined below.

[0941] The user inputs the requirements for the application they wish to develop in natural language from their device. For example, they might input something like, "I want to create a task management app. It will provide a function that allows users to add, edit, and delete tasks." The device is equipped with an emotion engine that analyzes the user's facial expressions and voice to collect emotional data, which is then sent to the server along with the requirements.

[0942] When the server receives the requirements, it analyzes them using a generative AI model (e.g., GPT-4) to extract specific program requirements. The results of this analysis also reflect the user's emotional data. For example, if the system determines that the user has time to spare, it can suggest more advanced features to the user.

[0943] The server then automatically generates backend (e.g., Node.js, Express, MongoDB) and frontend (e.g., React, Bootstrap) program code based on the extracted program requirements. Depending on the emotion data, the UI design and color scheme may also be adjusted.

[0944] The server then automatically generates unit and integration test code for the generated program code and immediately runs the tests. The test results are managed within the server, and initial bugs and issues can be identified based on the results.

[0945] The user can then use their device to check the generated program code and test results, and make any necessary modifications or customizations. During this process, the emotion engine analyzes the user's emotional data and provides appropriate feedback.

[0946] Finally, users prepare for release, check the configuration files and deployment scripts, and then deploy the application to a server or cloud environment to run it. Through this process, users can develop efficient and high-quality applications quickly.

[0947] Specific examples

[0948] As a specific example, a scene in which a user inputs the following prompt sentence will be shown.

[0949] I want to create a task management app that allows users to add, edit, and delete tasks.

[0950] Based on these requirements, the server analyzes them using a generative AI model and automatically generates the necessary program code and test code. The emotion engine detects the user's sense of security and stress, and provides feedback to adjust the UI and suggest improvements. This allows users to efficiently develop task management apps with intuitive and easy-to-use interfaces.

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

[0952] Step 1: Enter requirements

[0953] The user uses a device to input the application requirements in natural language. Specifically, they enter "I want to create a task management app. I want to provide a function that allows users to add, edit, and delete tasks" into an input field on the device's UI. At this time, the emotion engine analyzes the user's facial expressions and voice and collects emotional data. The inputs are the requirements and emotional data, which are converted into a data format and sent to the server as output.

[0954] Step 2: Submit your requirements

[0955] The device sends the request specifications and emotion data entered by the user to the server. Specifically, it uses a REST API or WebSocket to send a request including the request specifications and emotion data. The request specifications and emotion data are used as input, and the server receives them as output.

[0956] Step 3: Analyze requirements

[0957] The server analyzes the received requirements and uses a generative AI model (e.g., GPT-4) to extract specific program requirements. Emotional data is also used in the analysis, taking into account the user's emotions. The input is the requirements and emotional data, and the output is defined as program requirements.

[0958] Step 4: Automatic program generation

[0959] The server automatically generates program code based on the extracted program requirements. Using a generative AI model, back-end and front-end code is generated. For example, database models and API endpoints are generated for the back-end, and UI components are generated for the front-end. The program requirements are used as input, and the generated program code is obtained as output.

[0960] Step 5: Generate and run test code

[0961] The server automatically generates test code for the generated program code and executes the tests, including unit tests and integration tests. The input is the generated program code, and the test code is generated and executed, resulting in the test results as output.

[0962] Step 6: Human review and correction

[0963] The user uses the terminal to review the generated program code and test results. Specifically, they open the code in the terminal's IDE or text editor and make modifications and customizations as needed. The emotion engine provides feedback based on the user's progress. The input is the generated code and test results, and the output is the modified code and comments.

[0964] Step 7: Release preparation and deployment

[0965] The user prepares for release. After checking the configuration files and deployment scripts and completing the final checks, the user deploys the application to the server or cloud environment. Specifically, the deployment is performed by executing a command. The input is the finalized program code, and the output is a working application.

[0966] (Application example 2)

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

[0968] Conventional application development support systems have difficulty providing interfaces and functions that take user emotions into account, limiting the improvement of user experience. Furthermore, they are unable to intuitively recommend products based on user emotions in virtual stores, resulting in a less satisfying shopping experience.

[0969] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: means for a user to input application requirement specifications using a terminal; means for analyzing the received requirement specifications and extracting specific program requirements based on a generative AI model; means for automatically generating program code based on the extracted program requirements; means for generating test code for the automatically generated program code and automatically running tests based on the generated test code; means for checking the generated program code and test results, and modifying and customizing it as necessary; means for performing final testing and preparing for release, and deploying it to a server or cloud environment; means for recognizing user emotions using an emotion engine and providing feedback to the operation of the entire system; and means for displaying recommended products based on the user's emotion data. This enables customization based on the user's emotions, providing an intuitive and satisfying shopping experience in a virtual store.

[0970] "User" is the individual or end user who inputs the application requirements and reviews and modifies the generated code.

[0971] A "terminal" is a device that is operated by a user and provides a user interface for inputting required specifications and checking and correcting code.

[0972] A "server" is a computer system that analyzes the received requirements specifications, automatically generates program code and test code based on a generative AI model, and oversees processing on the system.

[0973] A "generative AI model" is an artificial intelligence model that extracts specific program requirements based on the requirements specifications entered by the user and automatically generates code.

[0974] "Program requirements" are specifications for specific functions and processes extracted based on the requirements analyzed by the generative AI model.

[0975] "Program code" refers to source code that is automatically generated by a generative AI model to realize various functions and processes.

[0976] "Test code" is code used to verify the operation of automatically generated program code.

[0977] The "emotion engine" is an engine that recognizes emotions from the user's facial expressions and voice and provides feedback to the system's operation.

[0978] "Recommended products" are products or services that are suggested to a user based on the user's emotional data recognized using the emotion engine.

[0979] "Deployment" is a method of transferring developed program code to an environment where it can actually be used and arranging it so that it can run.

[0980] The system that realizes this application example consists of the following elements: The user uses a terminal to input the application requirements in natural language. For example, they might input something like, "I want to create a task management app. It should provide a function that allows users to add, edit, and delete tasks." At this time, the emotion engine recognizes and records the user's emotions from their facial expressions, voice, etc.

[0981] The server analyzes the received requirements and extracts specific program requirements based on a generative AI model. The server then automatically generates back-end code (e.g., Django) and front-end code (e.g., React) based on the extracted program requirements. The UI design and color may be adjusted depending on the user's emotions, providing a user-friendly interface.

[0982] Next, the server generates test code for the automatically generated program code and automatically executes the tests. At this stage, basic unit tests and integration tests are performed to identify early bugs. The test results are managed within the server and provided to users for review and correction.

[0983] Users can use their devices to check the generated program code and test results, and correct any deficiencies or errors. The emotion engine collects users' emotional data during the project and provides feedback and suggestions for improvements based on this data, allowing users to work intuitively.

[0984] Finally, the user prepares the release, which includes checking configuration files and deployment scripts, after which the user deploys the application to a server or cloud environment and the application starts running.

[0985] A concrete example is a virtual store application. When a user launches the app, the camera captures the user's face and recognizes their emotions in real time. Based on the recognized emotional data, a list of recommended products is displayed. In this case, the hardware used is the smartphone's camera and microphone, and the software used is EmotionRecognizer and ProductRecommender.

[0986] Examples of prompts include:

[0987] "Please enter an image of the user smiling."

[0988] In this way, an application development support system that utilizes emotion recognition technology can be customized to suit the user's emotions, providing more intuitive and easy-to-use applications.

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

[0990] Step 1:

[0991] The user uses a device to input the application requirements in natural language. At this time, the user uses the interface on the device to input content such as, "I want to create a task management app. I want to provide a function that allows users to add, edit, and delete tasks." The user's requirements are sent as text data to the device as input. The device then sends this text data to the server.

[0992] Step 2:

[0993] The server analyzes the received requirements specification. It uses a generative AI model to extract specific program requirements from the text data. The input is the text data of the user's requirements specification, and the output is a list of specific program requirements. This analysis process uses natural language processing techniques to break down the text and extract key phrases and syntax.

[0994] Step 3:

[0995] The server automatically generates program code based on the extracted program requirements. The server uses a generative AI model to generate back-end code (using Django, for example) and front-end code (using React, for example). The output is a specific program code file.

[0996] Step 4:

[0997] The server generates corresponding test code for the automatically generated program code and automatically executes the tests based on this. The generated program code is used as input and goes through a transformation process to generate test code. The output is a log of the test results. The server systematically executes unit tests and integration tests to detect basic bugs and errors.

[0998] Step 5:

[0999] The user accesses the generated program code and test results using a terminal to view them. The user can view the code using an ID or text editor on the terminal and modify and customize it as needed. In this step, the user receives feedback generated based on the data analyzed by the emotion engine. The input is the generated code and test results, and the output is the modified and customized program code.

[1000] Step 6:

[1001] The user performs final testing and release preparation. Using a terminal, the user checks configuration files and deployment scripts and prepares the application for deployment to a server or cloud environment. The input is the finalized program code and configuration files, and the output is the deployed application, which is transferred to a working environment.

[1002] Step 7:

[1003] The emotion engine recognizes emotions from the user's facial expressions and voice and provides feedback to the operation of the entire system. Emotional data is analyzed and adjustments are made to improve the user experience. This data is used for UI design and product recommendations. The input is user emotional data, and the output is feedback and improvement suggestions for the system.

[1004] Step 8:

[1005] Recommendations are displayed based on the user's emotional data. The emotion engine recommends appropriate products and services based on the recognized emotion, thereby improving the user experience. The input is the recognized emotional data, and the output is a list of recommended products.

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

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

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

[1009] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1023] The present invention is an application development support system that utilizes generative AI, which automatically generates most of the program, and then has humans test and refine it to efficiently create high-quality applications. The following describes in detail the embodiments of the present invention.

[1024] 1. Main components

[1025] This system mainly consists of the following components:

[1026] User: Enters application requirements and reviews / modifies the generated code.

[1027] Terminal: A device used by the user to perform operations, providing a UI for inputting requirements and checking and modifying code.

[1028] Server: Analyzes the requirements specifications, automatically generates program code using a generative AI model, and also generates and executes test code.

[1029] 2. System Operation Overview

[1030] The operation of this system will be specifically explained below.

[1031] User input of requirements

[1032] The user uses a terminal to input the application requirements in natural language. For example, they might input something like, "I want to create a task management app that allows users to add, edit, and delete tasks."

[1033] Submitting and analyzing requirements

[1034] The terminal sends the requirements entered by the user to the server, which analyzes the received requirements and extracts specific program requirements based on the generative AI model. At this stage, the necessary database structure, API endpoints, etc. are defined.

[1035] Automatic program generation

[1036] The server automatically generates back-end and front-end program code based on the extracted program requirements. Specifically, it generates database models and API endpoints for the back-end, and UI components for the front-end.

[1037] Generate and run test code

[1038] The server also generates corresponding test code for the generated program code and automatically runs the tests, running basic unit and integration tests to uncover early bugs.

[1039] Human review and correction

[1040] The user uses a terminal to check the generated program code and test results, and if necessary, modify or customize the code. This is also the stage where the user can add their own functions or fine-tune the UI.

[1041] Release preparation and deployment

[1042] Finally, the user prepares the release, which includes checking configuration files and deployment scripts, and then deploys the application to a server or cloud environment, making it live and available to users.

[1043] Example: Task management app

[1044] As an example, consider a simple task management app that allows users to add, edit, and delete tasks.

[1045] 1. The user enters the requirements specification using a terminal.

[1046] 2. The server parses the requirements and defines the database structure (e.g., task table) and API endpoints.

[1047] 3. The server uses the generative AI model to automatically generate back-end and front-end program code.

[1048] 4. The server also generates test code for unit tests and integration tests and runs them automatically.

[1049] 5. The user reviews the generated code and test results and corrects any deficiencies or errors.

[1050] 6. Once the checks and corrections are complete, the user prepares the release and deploys the application.

[1051] In this way, by utilizing generative AI, the present invention provides an environment in which even beginners with no programming knowledge can easily develop high-quality applications. It is also effective in alleviating the declining labor force and labor shortages.

[1052] The processing flow will be explained below.

[1053] Step 1:

[1054] The user uses the device to enter the application requirements. Specifically, the user enters the requirements in natural language into a form or text area on the device, such as "I want to create a task management app. I want to provide a function that allows users to add, edit, and delete tasks." When the user has completed the input, they click the submit button.

[1055] Step 2:

[1056] The terminal sends the user's required specifications to the server. Specifically, it sends the required specifications to the server as an HTTP POST request. At this time, the terminal converts the input data into an appropriate format and performs error checks before sending it to the server.

[1057] Step 3:

[1058] The server analyzes the requirements received. Specifically, it uses natural language processing technology to convert the input requirements into program requirements. For example, from the requirements for a "task management app," it extracts that a "task table" and "CRUD operations" are required.

[1059] Step 4:

[1060] The server uses the generative AI model to automatically generate specific program code. For example, back-end code using Django and front-end code using React are generated. The server stores this code in an internal database.

[1061] Step 5:

[1062] The server also automatically generates and executes test code. Specifically, it generates unit test code and integration test code and executes the tests on the generated program code. The test results are managed within the server and used for subsequent processing.

[1063] Step 6:

[1064] The server compiles the test results and sends them to the device. Specifically, it generates a detailed report including the success / failure results of the test and an error log, and sends it to the device. This allows the user to check the quality of the generated code.

[1065] Step 7:

[1066] The user uses the terminal to check the generated program code and test results, specifically, opens the code using an IDE or text editor on the terminal, reviews the test results, and modifies or customizes the code as needed.

[1067] Step 8:

[1068] The user performs final testing and fixes, specifically testing the modified and customized code again to ensure all test cases pass, and repeating this process until the problem is resolved.

[1069] Step 9:

[1070] The user prepares for release and deploys the application. Specifically, the user checks the configuration files and deployment scripts, and executes the deployment command from the terminal to the server or cloud environment. If the deployment is successful, the application actually starts running.

[1071] Through each of these steps, the system of the present invention enables even beginners with no programming knowledge to develop high-quality applications quickly and efficiently.

[1072] Example 1

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

[1074] Modern application development requires advanced programming knowledge, making it difficult for beginners and non-technical people to develop high-quality applications. To improve development efficiency, it is necessary to not only automatically generate code, but also to integrate a series of tasks, such as automatic testing and deployment. Furthermore, the declining workforce and labor shortages are becoming more serious problems. A system that can solve these issues and enable efficient, high-quality application development is needed.

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

[1076] In this invention, the server includes: a means for a user to input application requirements using a terminal; a means for the terminal to transmit the user's requirements to the server; a means for the server to analyze the received requirements and extract specific program requirements based on a generative AI model using natural language processing technology; a means for the server to automatically generate back-end code and front-end code based on the extracted program requirements; a means for the server to generate test code for the automatically generated program code and automatically perform unit tests and integration tests based on the test code; a means for the user to check the generated program code and test results using a terminal and make modifications and customizations as necessary; and a means for the user to perform final testing and release preparation and deploy to a server or cloud environment. This enables even users with little programming knowledge to efficiently develop advanced applications. It also provides an innovative development environment that can address the declining workforce and labor shortages.

[1077] "User" refers to a person or organization whose role is to input application requirements specifications and to review and modify the generated program code and test results.

[1078] A "terminal" is a device that is operated by the user and provides a user interface for inputting required specifications and checking and modifying code.

[1079] "Server" refers to a computer system that has the ability to analyze user requirements and automatically generate program code using a generative AI model, as well as the ability to generate and execute test code.

[1080] "Requirements specifications" refers to information written in natural language by a user describing the functions and characteristics required for an application.

[1081] "Natural language processing technology" refers to technology for processing and analyzing human language using a computer.

[1082] A "generative AI model" refers to an artificial intelligence model that automatically generates program code and requirements based on provided data.

[1083] "Program requirements" refers to elements for defining the structure and functions of a specific program based on the analyzed requirements specifications.

[1084] "Back-end code" refers to the program code that performs the server-side processing of an application.

[1085] "Front-end code" refers to the program code that builds the user interface and manages the user's interaction with the application.

[1086] "Test code" refers to code for verifying the operation of generated program code.

[1087] A "unit test" refers to a test that verifies the operation of an individual program unit.

[1088] "Integration testing" refers to testing that verifies the operation of multiple program units combined together.

[1089] A "cloud environment" refers to an environment for using server resources and applications provided via the Internet.

[1090] This invention relates to an application development support system that utilizes a generative AI model. This system automatically generates program code and test code based on user-provided requirements, providing a method for efficiently developing high-quality applications.

[1091] Main components

[1092] This system mainly consists of the following components:

[1093] User: Enters application requirements and reviews / modifies the generated code.

[1094] Terminal: A device used by the user to perform operations, providing a user interface for inputting requirements and checking and modifying code.

[1095] Server: Analyzes the requirements specifications, automatically generates program code using a generative AI model, and generates and executes test code.

[1096] System Operation Overview

[1097] The operation of the system proceeds as follows.

[1098] Input of required specifications

[1099] The user inputs the application requirements in natural language using a terminal, for example, by entering the following prompt sentence:

[1100] I want to create a task management app that allows users to add, edit, and delete tasks.

[1101] Submitting and analyzing requirements

[1102] The terminal sends the requirements entered by the user to the server. The server analyzes the received requirements using natural language processing technology and extracts specific program requirements based on a generative AI model. Specifically, it extracts keywords and structures using natural language processing libraries such as SpaCy and NLTK, and inputs them into a generative AI model (e.g., GPT-3) to generate program requirements.

[1103] Automatic program generation

[1104] The server automatically generates program code based on the analysis results. The back-end code is primarily generated using Python and Flask, while the front-end code is generated using frameworks such as React. The database structure and API endpoints are also defined at the same time.

[1105] Generate and run test code

[1106] The server automatically generates test code for the generated program code, and uses test frameworks such as PyTest and Jest to run unit tests and integration tests and obtain test results.

[1107] Check and fix the code

[1108] The user can then use a terminal to review the generated program code and test results, modifying or customizing the code as needed. During this step, real-time code validation and suggestions are provided using a code editor such as VSCode.

[1109] Release preparation and deployment

[1110] Finally, the user checks the generated program configuration files and deployment scripts and deploys the application to a cloud environment (e.g., AWS, Azure, GCP), making the application available for use.

[1111] Specific examples

[1112] Here is a simple example of a task management app. The user enters the following prompt from the terminal:

[1113] I want to create a task management app that allows users to add, edit, and delete tasks.

[1114] Based on the above input, the server analyzes the requirements and defines the database structure for the task table and the necessary API endpoints. It then uses a generative AI model to automatically generate backend code (using Python and Flask) and frontend code (using React), and creates and runs test code for each. The user can then review and modify the generated code, and finally deploy it to a cloud environment. This series of processes enables the efficient development of a high-quality task management app.

[1115] This system allows even users with little programming knowledge to efficiently develop advanced applications, providing an effective development environment to address the declining workforce and labor shortages.

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

[1117] Step 1:

[1118] The user uses a device to input the application requirements. The user provides input in natural language into a form on the device. A specific example of input is provided: "I want to create a task management app. I want to provide functionality that allows users to add, edit, and delete tasks." This input prompt becomes the data for the next process.

[1119] Step 2:

[1120] The terminal sends the requirements entered by the user to the server. When the send button on the terminal is clicked, the requirements are sent to the server via the network. At this time, the entered natural language text is sent to the server endpoint as a POST request (input: natural language requirements, output: requirements passed to the server).

[1121] Step 3:

[1122] The server analyzes the received requirements using natural language processing techniques. For example, the server uses libraries such as SpaCy or NLTK to tokenize the text and extract key keywords and grammatical structures (input: natural language requirements, output: keywords and structured data).

[1123] Step 4:

[1124] The server provides prompts to the generative AI model based on the analysis results and extracts specific program requirements. The server generates program requirements from the requirements specification using, for example, GPT-3. These requirements include the database structure and API endpoints (input: analysis results, output: program requirements).

[1125] Step 5:

[1126] The server automatically generates back-end and front-end code based on the extracted program requirements. The back-end code is generated using Python and Flask, and the front-end code is generated using React (input: program requirements, output: automatically generated code).

[1127] Step 6:

[1128] The server generates test code for the generated program code and automatically executes unit tests and integration tests based on the generated code. For example, it generates test code using a test framework such as PyTest or Jest and automatically executes the tests (input: generated program code, output: test results).

[1129] Step 7:

[1130] The user can view the generated program code and test results using a terminal. A code editor (e.g., VSCode) or browser is displayed on the terminal, where the user can modify and customize the code (input: generated code and test results, output: modified code).

[1131] Step 8:

[1132] The user performs final testing and release preparation, then deploys to a server or cloud environment. The user checks the configuration files and deployment scripts and executes the deployment to the appropriate environment (input: final code and configuration files, output: deployed application).

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

[1134] (Application example 1)

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

[1136] Demand for video streaming services is increasing in modern society. However, operating a video streaming service requires advanced technical skills and significant resources, making it difficult for individuals and small and medium-sized enterprises to easily launch and operate a service. Furthermore, the complex development process and numerous testing and deployment procedures make it difficult to provide services quickly. Furthermore, while appropriate testing and user interface design are required to ensure code quality, there is a lack of automated methods for these processes.

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

[1138] In this invention, the server includes: a means for a user to input application requirements using a terminal; a means for the server to analyze the received requirements and extract specific program requirements based on a generative AI model; a means for the server to automatically generate program code based on the extracted program requirements; a means for the server to generate test code for the automatically generated program code and automatically run tests based on the test code; a means for the user to review the generated program code and test results and modify and customize it as necessary; a means for the user to perform final testing and release preparation and deploy it to a server or cloud environment; and a means for automatically generating functions for a video streaming service, allowing users to upload videos and for viewers to comment. This allows users to easily start and operate a video streaming service without advanced technical knowledge. Furthermore, automatic code generation and testing enables rapid and high-quality service provision.

[1139] "User" refers to a person or organization that inputs application requirements specifications, and reviews, modifies, customizes, and prepares the generated program code and test results for release.

[1140] A "terminal" is a device that a user operates and provides a user interface for inputting required specifications and checking and modifying code.

[1141] "Requirements specifications" are requirements regarding the functions and features of an application that are input by the user in natural language.

[1142] A "server" is a device or system that analyzes requirements received from a user, automatically generates program code and test code using a generative AI model, and then automatically executes tests based on this code.

[1143] A "generative AI model" is an artificial intelligence model that extracts specific program requirements based on required specifications and automatically generates corresponding program code.

[1144] "Program requirements" refer to the specific program components and functions extracted by the generative AI model.

[1145] "Program Code" means the back-end and front-end source code automatically generated by the Server.

[1146] "Test code" refers to code generated to check the basic operation of the generated program code.

[1147] "Deployment" refers to the procedure in which a user places the final application on a server or cloud environment and makes it available for use by users.

[1148] A "video streaming service" is a service that allows users to distribute videos over the Internet and allows viewers to watch those videos in real time or on demand.

[1149] The present invention provides an application development support system using a generative AI model, which supports automatic program generation and video streaming service operation. The following describes in detail an embodiment of the present invention.

[1150] Main components

[1151] The system mainly consists of the following components:

[1152] User: Enters application requirements and checks and modifies the generated program code and test results.

[1153] Terminal: A device used by the user to perform operations, providing a user interface for inputting requirements and checking and modifying code.

[1154] Server: Analyzes requirements specifications, automatically generates program code and test code using a generative AI model, and automatically executes tests based on this code.

[1155] System Operation Overview

[1156] Input of required specifications

[1157] The user uses a terminal to input the required specifications for the video streaming service in natural language. For example, they might input something like, "I want to create a video streaming service that allows users to upload videos and provides a function that allows viewers to comment."

[1158] Analysis of requirements specifications and extraction of program requirements

[1159] The server analyzes the received requirements and extracts specific program requirements based on the generative AI model, which defines the necessary database structure, API endpoints, etc.

[1160] Automatic generation of program code

[1161] The server automatically generates program code based on the extracted program requirements. For example, database models and API endpoints are defined on the backend, and UI components are automatically generated on the frontend. Specific features for video streaming services (such as video uploads and viewer comment functions) are also automatically generated.

[1162] Test code generation and automatic execution

[1163] The server then generates test code for the generated program code and automatically executes the tests, conducting unit tests and integration tests to identify any early defects.

[1164] Check and fix

[1165] The user uses a terminal to check the generated program code and test results, and can modify or customize the code as needed. This is also the stage where users can add their own functions or fine-tune the UI.

[1166] Release preparation and deployment

[1167] Finally, the user prepares the release and deploys it to a server or cloud environment, which then provides the actual video streaming service.

[1168] Hardware and software used

[1169] Hardware: Smartphone, PC (user device)

[1170] Software: Python, generative AI models, general-purpose frameworks, streaming servers (e.g., NGINX, Wowza)

[1171] Specific examples

[1172] Here is an example of a simple prompt:

[1173] "Generate application code for a video streaming service. It should allow users to upload videos and viewers to comment. It should also include a user management system."

[1174] Based on this prompt, the generative AI model automatically generates application code, which the user can review and modify before finally deploying.

[1175] This invention allows users to easily launch and operate a video streaming service without advanced technical knowledge, and the automatic code generation and testing enables rapid and high-quality service provision.

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

[1177] Step 1:

[1178] A user uses a device to input the requirements for a video streaming service in natural language. For example, they might input, "I want to create a video streaming service that allows users to upload videos and viewers to comment." This requirement becomes the input for the system.

[1179] Step 2:

[1180] The terminal sends the requirements input by the user to the server. At this stage, the requirements are sent in natural language as input data. The server receives them and prepares to start analysis.

[1181] Step 3:

[1182] The server analyzes the received requirements and extracts specific program requirements based on a generative AI model. The generative AI model analyzes the natural language requirements, identifies the necessary database structure and API endpoints, and outputs the program requirements. Specific operations include text data analysis and natural language processing.

[1183] Step 4:

[1184] Based on the program requirements extracted by the server, back-end and front-end program code is automatically generated. The generative AI model generates code based on the input program requirements and outputs the results. Specifically, the database model and API are defined on the back-end, and user interface components are generated on the front-end.

[1185] Step 5:

[1186] The server generates test code corresponding to the automatically generated program code and automatically executes the tests. Based on the input program code, it generates the necessary unit tests and integration tests and executes them. A report of the test results is obtained as output. Specifically, it performs static analysis of the code and executes dynamic tests.

[1187] Step 6:

[1188] The user uses a terminal to check the generated program code and test results. The inputs are the test result report and the generated program code, and the user can modify or customize it as needed. Specifically, modifications are made using a code editor or debugging tool.

[1189] Step 7:

[1190] The user performs final testing and release preparation, then deploys to a server or cloud environment. The input is the modified program code and configuration files, and the deployment is based on these. The output is a working video streaming service. Specific operations include running the deployment script and applying the server settings.

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

[1192] The present invention is an application development support system that utilizes generative AI and incorporates an emotion engine that recognizes user emotions. High-quality applications are efficiently created by automatically generating the majority of the program, followed by human testing and refinement. The following describes in detail the embodiments of the present invention.

[1193] 1. Main components

[1194] This system mainly consists of the following components:

[1195] User: Enters application requirements and reviews / modifies the generated code.

[1196] Terminal: A device used by the user to perform operations, providing a UI for inputting requirements and checking and modifying code.

[1197] Server: Analyzes the requirements specifications, automatically generates program code using a generative AI model, and also generates and executes test code.

[1198] Emotion engine: Recognizes user emotions and provides feedback to the overall system behavior.

[1199] 2. System Operation Overview

[1200] The operation of this system will be specifically explained below.

[1201] User input of requirements

[1202] The user uses a device to input the application requirements in natural language. For example, they might input something like, "I want to create a task management app. It should provide functions that allow users to add, edit, and delete tasks." At this time, the emotion engine recognizes and records the user's emotions from facial expressions, voice, and other factors.

[1203] Submitting and analyzing requirements

[1204] The device sends the requirements entered by the user to the server, which analyzes the received requirements and extracts specific program requirements based on the generative AI model. At this stage, the user's emotional data provided by the emotion engine is also reflected in the analysis results.

[1205] Automatic program generation

[1206] The server automatically generates back-end and front-end program code based on the extracted program requirements. For example, database models and API endpoints are generated on the back-end, and UI components are generated on the front-end. The UI design and color may also be adjusted based on the user's emotions.

[1207] Generate and run test code

[1208] The server also generates corresponding test code for the generated program code and automatically executes the tests. This executes basic unit tests and integration tests to identify early-stage bugs. The test results are managed within the server and used for subsequent processing.

[1209] Human review and correction

[1210] The user uses the device to check the generated program code and test results. Specifically, they open the code using the device's IDE or text editor and review the test results. They can then modify or customize the code as needed. The emotion engine also collects user emotion data during the project and provides feedback and suggestions for improvement.

[1211] Release preparation and deployment

[1212] Finally, the user prepares the release, which includes checking configuration files and deployment scripts. The user then deploys the application to a server or cloud environment. If the deployment is successful, the application goes live.

[1213] Example: Task management app

[1214] As an example, consider a simple task management app that allows users to add, edit, and delete tasks.

[1215] 1. The user inputs the required specifications using a terminal. At this time, the emotion engine analyzes the user's facial expressions and voice and records emotional data.

[1216] 2. The server analyzes the requirements and defines the database structure (e.g., task table) and API endpoints. Emotion data is also used for analysis.

[1217] 3. The server uses the generative AI model to automatically generate back-end and front-end program code. The UI design may be adjusted based on the emotion data.

[1218] 4. The server also generates test code for unit tests and integration tests and runs them automatically.

[1219] 5. The user reviews the generated code and test results, and fixes any deficiencies or errors. The emotion engine provides user feedback.

[1220] 6. Once the checks and corrections are complete, the user prepares the release and deploys the application.

[1221] In this way, by utilizing generative AI and an emotion engine, this invention enables even beginners with no programming knowledge to quickly and efficiently develop high-quality applications. In addition, by taking user emotions into consideration, it is possible to provide more intuitive and easy-to-use applications.

[1222] The processing flow will be explained below.

[1223] Step 1:

[1224] The user uses the device to input the application requirements. For example, the user might enter a requirement in natural language into a form or text area on the device, such as "I want to create a task management app. It should provide the ability for users to add, edit, and delete tasks." At this time, the emotion engine recognizes the user's face and analyzes their voice, and records their emotional data.

[1225] Step 2:

[1226] The device sends the user's requirements and emotion data to the server. Specifically, it sends the requirements entered using an HTTP POST request and the data collected by the emotion engine to the server.

[1227] Step 3:

[1228] The server analyzes the received requirements and emotion data. It then uses natural language processing technology to convert the requirements into program requirements and corrects the analysis results based on the emotion data. For example, if the user is nervous, it generates suggestions to simplify the interface to improve the user experience.

[1229] Step 4:

[1230] The server uses the generative AI model to automatically generate specific program code. For example, it generates back-end code using Django and front-end code using React. During this process, the UI color and design may change depending on the user's emotions.

[1231] Step 5:

[1232] The server also automatically generates test code and executes the tests. Specifically, it generates unit test code and integration test code and executes the tests on the generated application code. The test results are managed within the server and used for subsequent processing.

[1233] Step 6:

[1234] The server compiles the test results and sends them to the device. A detailed report is generated and sent to the device, including test success / failure results and error logs. The user can then check the quality of the generated code based on this.

[1235] Step 7:

[1236] The user uses the terminal to view the generated program code and test results, opens the code using an IDE or text editor on the terminal, reviews the test results, and modifies and customizes the code as needed.

[1237] Step 8:

[1238] The user performs final testing and fixes. The fixed and customized code is retested to ensure all test cases pass. This process is repeated until the issue is resolved.

[1239] Step 9:

[1240] The user prepares for release and deploys the application. They check the configuration files and deployment scripts, and execute the deployment command from the terminal to the server or cloud environment. If the deployment is successful, the application actually starts running.

[1241] Through these steps, the system of the present invention enables even beginners with no programming knowledge to quickly and efficiently develop high-quality applications. Furthermore, the emotion engine provides customization according to the user's emotions, improving the user experience.

[1242] Example 2

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

[1244] In the current application development process, automatic generation and testing of program code requires specialized knowledge, making it difficult for beginners and non-experts to develop efficiently.In addition, while the importance of interfaces and feedback that take user emotions into account is increasing, there is no system that can automatically reflect this.

[1245] The specification processing by the specification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes: means for a user to input application requirement specifications using a terminal; means for the server to analyze the received requirement specifications and extract specific program requirements based on a generative AI model; means for the server to automatically generate program code based on the extracted program requirements; means for the server to generate test code for the automatically generated program code and automatically execute tests based on the test code; means for a user to check the generated program code and test results and modify and customize it as necessary; means for a user to perform final testing and release preparation and deploy it to a server or cloud environment; and means for collecting and analyzing user emotion data using an emotion engine and providing feedback to the operation of the entire system. This allows even users without programming knowledge to efficiently develop high-quality applications, and enables interfaces and feedback that take user emotions into consideration to be automatically reflected.

[1246] A "terminal" is a device that a user operates, and is a device that allows text input and screen operation.

[1247] A "server" is a computer system that receives requests over a network and performs the specified processing.

[1248] "Requirements specifications" are documents or inputs that describe the specific requirements, such as the functions and performance, of the application that the user wants to develop.

[1249] A "generative AI model" is an artificial intelligence model used to analyze received requirements specifications and automatically generate specific program requirements.

[1250] "Program code" is code that describes specific instructions for a computer to execute.

[1251] "Test code" is code created to verify the accuracy and performance of generated program code.

[1252] "Test results" are the output and verification results obtained when test code is executed, and indicate the soundness of the program.

[1253] The "emotion engine" is a component that recognizes emotions from the user's facial expressions and voice, and provides feedback to the operation of the entire system.

[1254] "Deployment" is the process of placing an application that has been developed on a server or in a cloud environment and running it.

[1255] "Back-end code" is program code that runs on the server side and is responsible for managing databases and logic.

[1256] "Front-end code" is the program code that manages the interface with which the user directly interacts and the user interactions.

[1257] A "unit test" is a test that verifies the correctness of individual parts or components of a program.

[1258] "Integration testing" is testing that verifies whether multiple components or the entire system work together correctly.

[1259] "Natural language" refers to the language used by humans on a daily basis, and refers to the terms used in writing and conversation, rather than a specific programming language.

[1260] This invention is an application development support system that utilizes a generative AI model and an emotion engine. This system automatically generates program code based on user requirements and reflects the user's emotions as feedback in the overall system operation, thereby achieving efficient and high-quality application development.

[1261] System configuration

[1262] This system mainly consists of the following components:

[1263] Terminal: A device operated by the user that provides an interface for inputting required specifications and checking and correcting the generated code. The terminal is equipped with an emotion engine that recognizes emotions from the user's facial expressions and voice, and records the data.

[1264] Server: Analyzes the requirements specifications sent by the user and extracts specific program requirements using a generative AI model. It also has the ability to automatically generate program code and test code based on the extracted requirements and execute the tests.

[1265] Emotion engine: Collects and analyzes user emotional data and provides feedback to the system based on this.

[1266] Operation overview

[1267] The operation of this system will be specifically outlined below.

[1268] The user inputs the requirements for the application they wish to develop in natural language from their device. For example, they might input something like, "I want to create a task management app. It will provide a function that allows users to add, edit, and delete tasks." The device is equipped with an emotion engine that analyzes the user's facial expressions and voice to collect emotional data, which is then sent to the server along with the requirements.

[1269] When the server receives the requirements, it analyzes them using a generative AI model (e.g., GPT-4) to extract specific program requirements. The results of this analysis also reflect the user's emotional data. For example, if the system determines that the user has time to spare, it can suggest more advanced features to the user.

[1270] The server then automatically generates backend (e.g., Node.js, Express, MongoDB) and frontend (e.g., React, Bootstrap) program code based on the extracted program requirements. Depending on the emotion data, the UI design and color scheme may also be adjusted.

[1271] The server then automatically generates unit and integration test code for the generated program code and immediately runs the tests. The test results are managed within the server, and initial bugs and issues can be identified based on the results.

[1272] The user can then use their device to check the generated program code and test results, and make any necessary modifications or customizations. During this process, the emotion engine analyzes the user's emotional data and provides appropriate feedback.

[1273] Finally, users prepare for release, check the configuration files and deployment scripts, and then deploy the application to a server or cloud environment to run it. Through this process, users can develop efficient and high-quality applications quickly.

[1274] Specific examples

[1275] As a specific example, a scene in which a user inputs the following prompt sentence will be shown.

[1276] I want to create a task management app that allows users to add, edit, and delete tasks.

[1277] Based on these requirements, the server analyzes them using a generative AI model and automatically generates the necessary program code and test code. The emotion engine detects the user's sense of security and stress, and provides feedback to adjust the UI and suggest improvements. This allows users to efficiently develop task management apps with intuitive and easy-to-use interfaces.

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

[1279] Step 1: Enter requirements

[1280] The user uses a device to input the application requirements in natural language. Specifically, they enter "I want to create a task management app. I want to provide a function that allows users to add, edit, and delete tasks" into an input field on the device's UI. At this time, the emotion engine analyzes the user's facial expressions and voice and collects emotional data. The inputs are the requirements and emotional data, which are converted into a data format and sent to the server as output.

[1281] Step 2: Submit your requirements

[1282] The device sends the request specifications and emotion data entered by the user to the server. Specifically, it uses a REST API or WebSocket to send a request including the request specifications and emotion data. The request specifications and emotion data are used as input, and the server receives them as output.

[1283] Step 3: Analyze requirements

[1284] The server analyzes the received requirements and uses a generative AI model (e.g., GPT-4) to extract specific program requirements. Emotional data is also used in the analysis, taking into account the user's emotions. The input is the requirements and emotional data, and the output is defined as program requirements.

[1285] Step 4: Automatic program generation

[1286] The server automatically generates program code based on the extracted program requirements. Using a generative AI model, back-end and front-end code is generated. For example, database models and API endpoints are generated for the back-end, and UI components are generated for the front-end. The program requirements are used as input, and the generated program code is obtained as output.

[1287] Step 5: Generate and run test code

[1288] The server automatically generates test code for the generated program code and executes the tests, including unit tests and integration tests. The input is the generated program code, and the test code is generated and executed, resulting in the test results as output.

[1289] Step 6: Human review and correction

[1290] The user uses the terminal to review the generated program code and test results. Specifically, they open the code in the terminal's IDE or text editor and make modifications and customizations as needed. The emotion engine provides feedback based on the user's progress. The input is the generated code and test results, and the output is the modified code and comments.

[1291] Step 7: Release preparation and deployment

[1292] The user prepares for release. After checking the configuration files and deployment scripts and completing the final checks, the user deploys the application to the server or cloud environment. Specifically, the deployment is performed by executing a command. The input is the finalized program code, and the output is a working application.

[1293] (Application example 2)

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

[1295] Conventional application development support systems have difficulty providing interfaces and functions that take user emotions into account, limiting the improvement of user experience. Furthermore, they are unable to intuitively recommend products based on user emotions in virtual stores, resulting in a less satisfying shopping experience.

[1296] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: means for a user to input application requirement specifications using a terminal; means for analyzing the received requirement specifications and extracting specific program requirements based on a generative AI model; means for automatically generating program code based on the extracted program requirements; means for generating test code for the automatically generated program code and automatically running tests based on the generated test code; means for checking the generated program code and test results, and modifying and customizing it as necessary; means for performing final testing and preparing for release, and deploying it to a server or cloud environment; means for recognizing user emotions using an emotion engine and providing feedback to the operation of the entire system; and means for displaying recommended products based on the user's emotion data. This enables customization based on the user's emotions, providing an intuitive and satisfying shopping experience in a virtual store.

[1297] "User" is the individual or end user who inputs the application requirements and reviews and modifies the generated code.

[1298] A "terminal" is a device that is operated by a user and provides a user interface for inputting required specifications and checking and correcting code.

[1299] A "server" is a computer system that analyzes the received requirements specifications, automatically generates program code and test code based on a generative AI model, and oversees processing on the system.

[1300] A "generative AI model" is an artificial intelligence model that extracts specific program requirements based on the requirements specifications entered by the user and automatically generates code.

[1301] "Program requirements" are specifications for specific functions and processes extracted based on the requirements analyzed by the generative AI model.

[1302] "Program code" refers to source code that is automatically generated by a generative AI model to realize various functions and processes.

[1303] "Test code" is code used to verify the operation of automatically generated program code.

[1304] The "emotion engine" is an engine that recognizes emotions from the user's facial expressions and voice and provides feedback to the system's operation.

[1305] "Recommended products" are products or services that are suggested to a user based on the user's emotional data recognized using the emotion engine.

[1306] "Deployment" is a method of transferring developed program code to an environment where it can actually be used and arranging it so that it can run.

[1307] The system that realizes this application example consists of the following elements: The user uses a terminal to input the application requirements in natural language. For example, they might input something like, "I want to create a task management app. It should provide a function that allows users to add, edit, and delete tasks." At this time, the emotion engine recognizes and records the user's emotions from their facial expressions, voice, etc.

[1308] The server analyzes the received requirements and extracts specific program requirements based on a generative AI model. The server then automatically generates back-end code (e.g., Django) and front-end code (e.g., React) based on the extracted program requirements. The UI design and color may be adjusted depending on the user's emotions, providing a user-friendly interface.

[1309] Next, the server generates test code for the automatically generated program code and automatically executes the tests. At this stage, basic unit tests and integration tests are performed to identify early bugs. The test results are managed within the server and provided to users for review and correction.

[1310] Users can use their devices to check the generated program code and test results, and correct any deficiencies or errors. The emotion engine collects users' emotional data during the project and provides feedback and suggestions for improvements based on this data, allowing users to work intuitively.

[1311] Finally, the user prepares the release, which includes checking configuration files and deployment scripts, after which the user deploys the application to a server or cloud environment and the application starts running.

[1312] A concrete example is a virtual store application. When a user launches the app, the camera captures the user's face and recognizes their emotions in real time. Based on the recognized emotional data, a list of recommended products is displayed. In this case, the hardware used is the smartphone's camera and microphone, and the software used is EmotionRecognizer and ProductRecommender.

[1313] Examples of prompts include:

[1314] "Please enter an image of the user smiling."

[1315] In this way, an application development support system that utilizes emotion recognition technology can be customized to suit the user's emotions, providing more intuitive and easy-to-use applications.

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

[1317] Step 1:

[1318] The user uses a device to input the application requirements in natural language. At this time, the user uses the interface on the device to input content such as, "I want to create a task management app. I want to provide a function that allows users to add, edit, and delete tasks." The user's requirements are sent as text data to the device as input. The device then sends this text data to the server.

[1319] Step 2:

[1320] The server analyzes the received requirements specification. It uses a generative AI model to extract specific program requirements from the text data. The input is the text data of the user's requirements specification, and the output is a list of specific program requirements. This analysis process uses natural language processing techniques to break down the text and extract key phrases and syntax.

[1321] Step 3:

[1322] The server automatically generates program code based on the extracted program requirements. The server uses a generative AI model to generate back-end code (using Django, for example) and front-end code (using React, for example). The output is a specific program code file.

[1323] Step 4:

[1324] The server generates corresponding test code for the automatically generated program code and automatically executes the tests based on this. The generated program code is used as input and goes through a transformation process to generate test code. The output is a log of the test results. The server systematically executes unit tests and integration tests to detect basic bugs and errors.

[1325] Step 5:

[1326] The user accesses the generated program code and test results using a terminal to view them. The user can view the code using an ID or text editor on the terminal and modify and customize it as needed. In this step, the user receives feedback generated based on the data analyzed by the emotion engine. The input is the generated code and test results, and the output is the modified and customized program code.

[1327] Step 6:

[1328] The user performs final testing and release preparation. Using a terminal, the user checks configuration files and deployment scripts and prepares the application for deployment to a server or cloud environment. The input is the finalized program code and configuration files, and the output is the deployed application, which is transferred to a working environment.

[1329] Step 7:

[1330] The emotion engine recognizes emotions from the user's facial expressions and voice and provides feedback to the operation of the entire system. Emotional data is analyzed and adjustments are made to improve the user experience. This data is used for UI design and product recommendations. The input is user emotional data, and the output is feedback and improvement suggestions for the system.

[1331] Step 8:

[1332] Recommendations are displayed based on the user's emotional data. The emotion engine recommends appropriate products and services based on the recognized emotion, thereby improving the user experience. The input is the recognized emotional data, and the output is a list of recommended products.

[1333] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

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

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

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

[1337] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1338] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1339] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

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

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

[1342] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1343] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1344] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

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

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

[1347] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1348] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1349] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1350] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1351] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1352] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1353] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1354] The following is further disclosed regarding the above embodiment.

[1355] (Claim 1)

[1356] A means for a user to input application requirements using a terminal;

[1357] A means for analyzing the requirements specification received by the server and extracting specific program requirements based on the generative AI model;

[1358] means for automatically generating program code based on the program requirements extracted by the server;

[1359] A means for the server to generate test code for the automatically generated program code and automatically execute the test based on the test code;

[1360] A means for users to review the generated program code and test results and make modifications and customizations as necessary;

[1361] A means for users to perform final testing and release preparation and deploy to a server or cloud environment;

[1362] A system including:

[1363] (Claim 2)

[1364] 2. The system of claim 1, wherein the server further comprises means for generating backend code using Django and frontend code using React, and means for automatically executing unit tests and integration tests.

[1365] (Claim 3)

[1366] 2. The system according to claim 1, further comprising means for allowing a user to input a requirement specification in natural language, and for analyzing the input specification to convert it into specific program requirements.

[1367] "Example 1"

[1368] (Claim 1)

[1369] A means for a user to input application requirements using a terminal;

[1370] A means for the terminal to transmit the user's required specifications to the server;

[1371] A means for analyzing the requirements specification received by the server and extracting specific program requirements based on a generative AI model using natural language processing technology;

[1372] means for automatically generating back-end code and front-end code based on the program requirements extracted by the server;

[1373] a means for the server to generate test code for the automatically generated program code and automatically execute unit tests and integration tests based on the generated test code;

[1374] A means for a user to use a terminal to check the generated program code and test results, and to modify and customize them as necessary;

[1375] A means for users to perform final testing and release preparation and deploy to a server or cloud environment;

[1376] A system including:

[1377] (Claim 2)

[1378] 2. The system of claim 1, wherein the server further comprises means for generating back-end code using a generic programming framework and generating front-end code using generic user interface technology, and means for automatically performing unit tests and integration tests.

[1379] (Claim 3)

[1380] 2. The system according to claim 1, further comprising means for allowing a user to input a requirement specification in natural language, analyzing the input, and converting the input into specific program requirements.

[1381] "Application Example 1"

[1382] (Claim 1)

[1383] A means for a user to input application requirements using a terminal;

[1384] A means for analyzing the requirements specification received by the server and extracting specific program requirements based on the generative AI model;

[1385] means for automatically generating program code based on the program requirements extracted by the server;

[1386] A means for the server to generate test code for the automatically generated program code and automatically execute the test based on the test code;

[1387] A means for users to review the generated program code and test results and make modifications and customizations as necessary;

[1388] A means for users to perform final testing and release preparation and deploy to a server or cloud environment;

[1389] A means for automatically generating functionality for video streaming services, allowing users to upload videos and viewers to comment;

[1390] A system including:

[1391] (Claim 2)

[1392] 2. The system of claim 1, wherein the server further comprises means for generating back-end code using a generic framework and front-end code using a generic library, and means for automatically executing unit tests and integration tests.

[1393] (Claim 3)

[1394] 2. The system according to claim 1, further comprising means for allowing a user to input a requirement specification in natural language, and for analyzing the input specification to convert it into specific program requirements.

[1395] "Example 2: Combining Emotion Engines"

[1396] (Claim 1)

[1397] A means for a user to input application requirements using a terminal;

[1398] A means for analyzing the requirements specification received by the server and extracting specific program requirements based on the generative AI model;

[1399] means for automatically generating program code based on the program requirements extracted by the server;

[1400] A means for the server to generate test code for the automatically generated program code and automatically execute the test based on the test code;

[1401] A means for users to review the generated program code and test results and make modifications and customizations as necessary;

[1402] A means for users to perform final testing and release preparation and deploy to a server or cloud environment;

[1403] A means to collect and analyze user emotional data using an emotion engine and provide feedback to the overall operation of the system;

[1404] A system including:

[1405] (Claim 2)

[1406] 10. The system of claim 1, wherein the server further comprises means for automatically generating back-end code and front-end code and automatically performing unit and integration tests.

[1407] (Claim 3)

[1408] 2. The system according to claim 1, further comprising means for allowing a user to input a requirement specification in natural language, and for analyzing the input specification to convert it into specific program requirements.

[1409] "Application example 2 when combining emotion engines"

[1410] (Claim 1)

[1411] A means for a user to input application requirements using a terminal;

[1412] A means for analyzing the requirements specification received by the server and extracting specific program requirements based on the generative AI model;

[1413] means for automatically generating program code based on the program requirements extracted by the server;

[1414] A means for the server to generate test code for the automatically generated program code and automatically execute the test based on the test code;

[1415] A means for users to review the generated program code and test results and make modifications and customizations as necessary;

[1416] A means for users to perform final testing and release preparation and deploy to a server or cloud environment;

[1417] a means for recognizing a user's emotions using an emotion engine and feeding the emotions back to the overall system operation;

[1418] A means for displaying recommended products based on the user's emotion data;

[1419] A system including:

[1420] (Claim 2)

[1421] The system of claim 1, further comprising: a server generating back-end code using Django and front-end code using React; and a means for automatically executing unit tests and integration tests; and a means for adjusting UI design based on user emotion data.

[1422] (Claim 3)

[1423] 2. The system according to claim 1, further comprising means for allowing a user to input a requirement specification in natural language, and for analyzing the input specification to convert it into specific program requirements. [Explanation of symbols]

[1424] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. A means for a user to input application requirements using a terminal; A means for analyzing the requirements specification received by the server and extracting specific program requirements based on the generative AI model; means for automatically generating program code based on the program requirements extracted by the server; A means for the server to generate test code for the automatically generated program code and automatically execute the test based on the test code; A means for users to review the generated program code and test results and make modifications and customizations as necessary; A means for users to perform final testing and release preparation and deploy to a server or cloud environment; A system including:

2. The system of claim 1 , wherein the server further comprises means for generating back-end code using Django and front-end code using React, and means for automatically executing unit tests and integration tests.

3. 2. The system according to claim 1, further comprising means for allowing a user to input a requirement specification in natural language, and for analyzing the input specification to convert it into specific program requirements.

Images