Program, information processing method, and information processing device
Patent Information
- Application Number
- JP2024162276
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2023-04-21
- Filing Date
- 2024-09-19
- Publication Date
- 2024-11-28
AI Technical Summary
【0007】 一つの側面では、ソフトウェアの設計スキル又は開発スキルを必要とせずにソフトウェアの設計及び開発を行うことが可能となる。
Smart Images

Figure 2024166397000001_ABST
Abstract
Description
[Technical field]
[0001] The present disclosure relates to a program, an information processing method, and an information processing device. [Background technology]
[0002] Patent Document 1 discloses a technique for selecting pre-prepared parts and setting the layout information, attribute information, and setting items of the selected parts via a graphical interface when designing the screen of software having a graphical user interface (GUI). By using such a technique, even an engineer who does not have high-level design skills in screen design can easily design the execution screen of the software. [Prior art documents] [Patent documents]
[0003] [Patent Document 1] Patent No. 6570436 Summary of the Invention [Problem to be solved by the invention]
[0004] In recent years, the speed of software version upgrades and specification changes has been rapid, and there is a demand for faster software design and development. Therefore, there is a demand for a system that allows software design and development without requiring much software design or development skill.
[0005] In one aspect, an object of the present invention is to provide a program or the like that enables software design and development without requiring software design or development skills. [Means for solving the problem]
[0006] A program relating to one aspect causes a computer to execute a process of receiving a summary prompt indicating an overview of program code to be generated, inputting the received summary prompt into a natural language processing model to obtain a detail prompt indicating detailed specifications of the program code, and inputting the obtained detail prompt into the natural language processing model to obtain the program code. Effect of the Invention
[0007] In one aspect, software design and development can be performed without the need for software design or development skills. [Brief description of the drawings]
[0008] [Figure 1] 1 is a block diagram showing an example of the configuration of an information processing device; [Diagram 2] 13 is a flowchart illustrating an example of a program code generation process. [Diagram 3] 13 is a flowchart illustrating an example of a program code generation process. [Figure 4] 13 is a flowchart illustrating an example of a program code generation process. [Diagram 5] 13 is a flowchart illustrating an example of a program code generation process. [Figure 6] 13 is a flowchart illustrating an example of a program code generation process. [Figure 7A] FIG. 13 is an explanatory diagram showing an example of a screen. [Figure 7B] FIG. 13 is an explanatory diagram showing an example of a screen. [Figure 8] FIG. 13 is an explanatory diagram showing an example of a screen. [Figure 9] FIG. 13 is an explanatory diagram showing an example of a screen. [Figure 10A] FIG. 13 is an explanatory diagram showing an example of a screen. [Figure 10B] FIG. 13 is an explanatory diagram showing an example of a screen. [Figure 11] FIG. 13 is an explanatory diagram showing an example of a screen. [Figure 12] FIG. 13 is an explanatory diagram showing an example of a screen. [Figure 13] FIG. 13 is an explanatory diagram showing an example of a screen. [Figure 14] 13 is a flowchart showing an example of a program code generation processing procedure according to the second embodiment. [Figure 15] FIG. 13 is an explanatory diagram showing a modified example of the application design screen. [Figure 16] 13 is a flowchart showing an example of a program code generation processing procedure according to the third embodiment. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0009] Hereinafter, a program, an information processing method, and an information processing device according to the present disclosure will be described in detail with reference to the drawings showing embodiments thereof.
[0010] (Embodiment 1) In this embodiment, an information processing device that designs and develops an application program (software, hereinafter simply referred to as an application) using instructions (prompts) in natural language (text data) and images, etc., will be described. The information processing device of this embodiment can support not only the work of a user designing an application, but also the work of developing an application. Hereinafter, the design and development of an application will be collectively referred to as application design. In this embodiment, an example will be described in which Japanese is used as the natural language, but the natural language is not limited to Japanese, and languages other than Japanese, such as English, French, Vietnamese, and Chinese, may also be used. FIG. 1 is a block diagram showing an example of the configuration of an information processing device.
[0011] The information processing device 10 is a computer capable of various information processing and transmitting and receiving information, and is a server computer or a personal computer. The information processing device 10 includes a control unit 11, a storage unit 12, a communication unit 13, an input unit 14, a display unit 15, a reading unit 16, and the like, and these units are connected to each other via a bus. The control unit 11 is configured using one or more processors such as a CPU (Central Processing Unit), an MPU (Micro-Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-purpose computing on graphics processing units), a TPU (Tensor Processing Unit), or an AI chip (AI semiconductor). The control unit 11 executes various information processing and control processing to be performed by the information processing device 10 by appropriately executing a program P stored in the storage unit 12. Note that when the control unit 11 includes multiple processors, the control unit 11 may execute each process by a different processor.
[0012] The storage unit 12 includes a RAM (Random Access Memory), a flash memory, a hard disk, an SSD (Solid State Drive), and the like. The storage unit 12 stores a program P (program product) executed by the control unit 11 and various data required for executing the program P. The storage unit 12 also stores an application (hereinafter referred to as a design support application AP) for realizing a process for supporting the design of an application (generation of a program code). The storage unit 12 also temporarily stores data and the like generated when the control unit 11 executes the program P and the design support application AP. The storage unit 12 further stores a natural language processing model M. The natural language processing model M is a general-purpose large-scale language model (LLM: Large Language Models) constructed by performing unsupervised pre-learning using a large-scale text group, and the like. The natural language processing model M is trained to perform a calculation to generate output data according to the contents of the input data based on the input data when input data including, for example, text data and / or image data described in a natural language is input, and to output the generated output data. The natural language processing model M can be configured using algorithms such as GPT (Generative Pre-trained Transformer)-3, GPT-3.5, GPT-4, RWKV, etc., and may be configured by combining a plurality of algorithms. The natural language processing model M is not limited to the above-mentioned transformer-based model and RNN (Recurrent Neural Network)-based model. The natural language processing model M is expected to be used as a program module constituting artificial intelligence software. The natural language processing model M performs a predetermined calculation on input data and outputs the calculation result, and the storage unit 12 stores data such as coefficients and thresholds of functions that define this calculation as the natural language processing model M. Instead of storing the natural language processing model M in the storage unit 12, the information processing device 10 may access a language processing server that stores the natural language processing model M and read it out.
[0013] The communication unit 13 is a communication module for performing processes related to wired or wireless communication, and transmits and receives information to and from other devices via a network. The network may be the Internet or a public telephone line network, or may be a LAN (Local Area Network) constructed in a facility where the information processing device 10 is installed. The input unit 14 accepts an operation input by a user, and sends a control signal corresponding to the operation content to the control unit 11. The input unit 14 includes, for example, a keyboard and a mouse, and a microphone for voice input. The display unit 15 is a liquid crystal display or an organic EL display, and displays various information according to instructions from the control unit 11. A part of the input unit 14 and the display unit 15 may be a touch panel configured as an integrated unit.
[0014] The reading unit 16 reads information stored in a portable storage medium 10a including a CD (Compact Disc), a DVD (Digital Versatile Disc), a USB (Universal Serial Bus) memory, an SD (Secure Digital) card, etc. The program P and the design support application AP stored in the storage unit 12 may be read by the control unit 11 from the portable storage medium 10a via the reading unit 16 and stored in the storage unit 12. In addition, the program P and the design support application AP may be written in the storage unit 12 during the manufacturing stage of the information processing device 10, or the control unit 11 may download them from another device via the communication unit 13 and store them in the storage unit 12.
[0015] In this embodiment, the information processing device 10 may be a multi-computer consisting of multiple computers, or may be a virtual machine virtually constructed by software in one device. In addition, when the information processing device 10 is configured as a server computer, the information processing device 10 may be a local server installed in a facility where the information processing device 10 is installed, or may be a cloud server connected to the information processing device 10 via a network such as the Internet. In the following, the information processing device 10 will be described as being one computer. In addition, the program P and the design support application AP may be executed on a single computer, or may be distributed and executed on multiple computers connected to each other via a network. Furthermore, the input unit 14 and the display unit 15 are not essential for the information processing device 10, and the information processing device 10 may be configured to accept operations through a connected computer, or to output information to be displayed to an external display device.
[0016] When generating a computer program (program code), the information processing device 10 having the above-mentioned configuration receives an outline of the program code to be generated in at least one of text data written in a natural language, text data converted from voice data spoken in a natural language, and image data. The outline data received by the information processing device 10 is hereinafter referred to as an outline prompt. The information processing device 10 executes a process of generating a detail prompt (hereinafter referred to as an intermediate prompt) in which detailed specification contents of the program code to be generated are written in a natural language from the received outline prompt, using the natural language processing model M. Then, the information processing device 10 executes a process of generating program code from the intermediate prompt, using the natural language processing model M. In this way, the information processing device 10 of this embodiment uses the natural language processing model M when generating an intermediate prompt from the outline prompt and when generating program code from the intermediate prompt. The information processing device 10 is configured to accept edits to the intermediate prompt using at least one of text data written in a natural language, text data converted from voice data spoken in a natural language, and image data, and updates (modifies) the program code by inputting the edited intermediate prompt to the natural language processing model M. The information processing device 10 of this embodiment also performs processes such as accepting input of an intermediate prompt and generating program code from the accepted intermediate prompt, accepting setting contents and the like in the program code to be generated via a GUI, and generating program code based on the accepted setting contents and the like.
[0017] The process of generating a program code by the information processing device 10 of this embodiment will be described below. Figures 2 to 6 are flowcharts showing an example of the program code generation process procedure, and Figures 7A to 13 are explanatory diagrams showing example screens. The following process is executed by the control unit 11 of the information processing device 10 in accordance with the program P and design support application AP stored in the storage unit 12.
[0018] A user who designs an application (generates a program code) instructs the information processing device 10 to start a design support application AP. When the control unit 11 of the information processing device 10 receives an instruction to start the design support application AP via the input unit 14, the control unit 11 starts the design support application AP and executes the following processing.
[0019] When the control unit 11 of the information processing device 10 starts the design support application AP, the control unit 11 displays, as an initial screen, a screen (not shown) having a button for accepting an instruction to create a new application and a button for accepting an instruction to create (update) an application being created, on the display unit 15. When the control unit 11 accepts an instruction to create a new application via such an initial screen, the control unit 11 displays an application name input screen on the display unit 15 (S11). The control unit 11 displays, for example, an application name input screen as shown in FIG. 7A. The screen shown in FIG. 7A has an input field for an application name to be given to a newly created application, and a Create button for instructing to start generating an application with the input application name. Note that the application name input screen may be provided with an input field for meta information such as a description regarding the application to be created, in addition to the input field for the application name. The control unit 11 accepts input of an application name via the input unit 14 into the input field in the application name input screen (S12). When the control unit 11 accepts input of an application name, the control unit 11 displays the accepted application name in the input field.
[0020] The control unit 11 judges whether or not the Create button in the application name input screen has been operated (S13), and if it judges that it has not been operated (S13: NO), the process returns to step S12 and continues to accept input of the application name in the input field. If it judges that the Create button in the application name input screen has been operated (S13: YES), the control unit 11 displays an application design screen for a newly created application on the display unit 15 (S14). The control unit 11 displays an application design screen as shown in FIG. 7B, for example. The screen shown in FIG. 7B is a design screen that accepts operations for designing an application with an application name of "AAA App". The screen shown in FIG. 7B has a menu field R1, a GUI field R2, and a prompt wizard field R3. The menu field R1 displays menu items for selecting items that can be set for the application to be generated, and in the example of FIG. 7B, menu items of Data, Screen, Theme, Language, and Others are displayed. The menu items are not limited to the example in Fig. 7B, and may be changeable (added and deleted) for each user or for each application to be generated. Also, the menu items may be configured to be arbitrarily set, for example, the menu items Data and Screen are required items, and other menu items are changeable.
[0021] The GUI field R2 is an area that accepts input of setting information related to each item that can be set for the application via a graphical interface. When any of the menu items displayed in the menu field R1 is selected, the GUI field R2 switches and displays a screen that accepts input of setting information for the selected menu item. FIG. 7B shows an example of a display when the Data menu item is selected. Note that Data is a menu item for accepting input of setting information related to data handled by the application, Screen is a menu item for accepting input of setting information related to a display screen in the application, Theme is a menu item for accepting input of setting information related to a theme color in the application, Language is a menu item for accepting input of setting information related to a language used in the application, and Others is a menu item for accepting input of setting information related to contents other than the above.
[0022] In the GUI field R2 shown in FIG. 7B, an input field I1 for inputting the name of data (e.g., a database) to be newly created, and a +Add button for instructing the creation of a database with the name input in the input field I1 are provided. When the name of the database is input in the input field I1 and the +Add button is operated, the control unit 11 of the information processing device 10 displays an input screen (not shown) for information on the database to be newly created, and accepts input of information on the database via the input screen. The input screen here has input fields for accepting input of, for example, the type of database (data store) (e.g., information on the purpose), the name of the data field the database has, the type of data stored in each data field (e.g., alphabet, numbers, symbols, etc.), the number of digits, the amount of data, etc. When input of information on a new database is accepted via such an input screen, the control unit 11 of the information processing device 10 ends the display of the input screen and displays the input information on the database in the GUI field R2. 7B shows the initial state of the application design screen, so nothing is displayed in GUI field R2, but when information about a database is input, for example, the name of the database (Data-Name), the ID assigned to the database, the type of the database (Type), etc. are displayed. When setting information for each menu item is input via GUI field R2, control unit 11 of information processing device 10 reflects the input setting information in prompt wizard field R3.
[0023] The prompt wizard field R3 is an area for accepting setting information on each item that can be set for the application by inputting natural language and / or images, etc., and has a summary prompt field I2 and an intermediate prompt field I3, etc. FIG. 7B shows an initial state, so the summary prompt field I2 and the intermediate prompt field I3 are blank (blank) with nothing displayed. The summary prompt field I2 is an input field for accepting input of a summary prompt including an overview and purpose of the application to be generated by any one or more of natural language (text data), images, and voice input. The summary prompt field I2 is also configured to accept input of execution instructions for processing to be executed by the control unit 11 of the information processing device 10 according to the design support application AP, such as an instruction to change an intermediate prompt that has already been generated, an instruction to change a program code that has already been generated, an instruction to commit a program code being created, an instruction to execute a build process for the program code, etc., by any one or more of natural language, images, and voice input. The intermediate prompt field I3 is a preview field that displays the detailed specification contents (intermediate prompt) of the application to be generated in natural language, and is configured to allow editing (changing) of the displayed specification contents. In this embodiment, the intermediate prompt field I3 displays the specification contents (intermediate prompt) generated for each menu item from the overview prompt input in the overview prompt field I2 using the natural language processing model M. The intermediate prompt field I3 is configured so that an intermediate prompt can be directly input via the input unit 14, and displays the intermediate prompt generated from the overview prompt as well as the directly input intermediate prompt. Specifically, the intermediate prompt field I3 is provided corresponding to each menu item displayed in the menu field R1, and displays information regarding the setting contents of each menu item. In the example of FIG. 7B, the intermediate prompt field I3 of Data Schema (data structure) displays information regarding the setting contents of the Data menu item, and displays, for example, specifications regarding the structure of a database used in an application (for example, the type of database, the name of a data field, and the type of data).The Screen Definition intermediate prompt field I3 displays information about the setting contents of the Screen menu items, for example, specifications about the configuration of the screen used in the application and specifications about screen transitions (routing). The Theme Color intermediate prompt field I3 displays information about the setting contents of the Theme menu items, for example, specifications about the theme color set for the entire application. The Language intermediate prompt field I3 displays information about the setting contents of the Language menu items, for example, the type of language used in the application. The Others intermediate prompt field I3 displays information about the setting contents of the Others menu items, for example, displaying setting information about items to be defined other than the above-mentioned specification contents (intermediate prompts). The intermediate prompt field I3 is configured to accept edits (changes) to the displayed intermediate prompts by any one or more of natural language (text data), images, and voice input. The intermediate prompt field I3 is not limited to the example of FIG. 7B, and is not limited to the configuration corresponding to each menu item. For example, the Language intermediate prompt column I3 may not be provided, and information about the settings of the Language menu item may be displayed in the Others intermediate prompt column I3. Also, if a menu item is changeable, an intermediate prompt column I3 corresponding to the changed menu item is provided in the prompt wizard column R3.
[0024] In the prompt wizard field R3 shown in FIG. 7B, the summary prompt field I2 is configured to accept text input via the input unit 14. The summary prompt field I2 is also configured to accept an application summary prompt by image input or voice input via a microphone, and is provided with an image input button B1 and a voice input button B2. When the image input button B1 is operated, the control unit 11 of the information processing device 10 displays a selection screen (not shown) for selecting an arbitrary image file stored in the storage unit 12 or the like, and accepts the selection of an image file in which the summary of the application is described via the selection screen. The image file here is a file containing an image in which the summary of the application is described in characters (natural language), and for example, an image file obtained by reading a paper on which the summary of the application is handwritten with a scanner can be used. The image file may include text data in addition to the image. The data of the image file may be an image image that cannot be converted into natural language (characters) in addition to character information, and may be image data generated using an image generation AI that generates an image by inputting text data or the like. When the voice input button B2 is operated, the control unit 11 of the information processing device 10 collects sound using the microphone of the input unit 14, acquires voice data uttered by the user, generates text data of the spoken content by performing voice recognition processing on the acquired voice data, and acquires the generated text data as a summary prompt. The summary prompt field I2 may be configured to accept input of the summary prompt by a text file in which the summary of the application is described in text data. The summary prompt field I2 may be configured to accept input of the summary prompt by data of any type or format, such as a video file, a pdf (Portable Document Format) file, or a binary file. The summary prompt field I2 may be configured to accept input of the summary prompt interactively.For example, a question regarding the summary prompt may be displayed in the summary prompt field I2, and the summary prompt may be input by the user inputting an answer to the question. Alternatively, for example, when the user inputs a summary prompt, the control unit 11 may input the input summary prompt to the natural language processing model M, and display output data output from the natural language processing model M as an answer, and the user may input an additional summary prompt in response to this answer, thereby inputting the summary prompt.
[0025] In the prompt wizard field R3 of FIG. 7B, an Apply button B3 is provided in association with the summary prompt field I2 for instructing the execution of a process for generating an intermediate prompt based on the summary prompt input in the summary prompt field I2. In addition, an Apply button B4 is provided in association with the intermediate prompt field I3 for instructing the execution of a process for generating program code based on the intermediate prompt displayed in each intermediate prompt field I3. In addition, a screen switching button B5 is provided in the display area of the GUI field R2 and the prompt wizard field R3 for instructing the display of only the prompt wizard field R3 on a large screen. Furthermore, in the prompt wizard field R3 of FIG. 7B, a history display field R4 is provided, in which update history information for the intermediate prompt is displayed. Specifically, the history display field R4 displays the generation history or change history of the intermediate prompt when the intermediate prompt is generated or changed based on the summary prompt input in the summary prompt field I2, and displays the input history or change history of the intermediate prompt when the intermediate prompt is input or changed in the intermediate prompt field I3. In addition, when the program code is input or changed via the GUI field R2, the change history of the intermediate prompt is displayed in the history display field R4 after the intermediate prompt is generated from the updated program code. 7B shows the initial state, nothing is displayed in the history display field R4 in Fig. 7B, but history information indicating, for example, that the creation of an application has started may be displayed. The above-mentioned change history information is managed by version information (version number) indicating the order in which the intermediate prompt was generated or changed, and is configured so that the user can return the intermediate prompt and program code to the version state desired and re-update the intermediate prompt and program code from the state of that version.For example, the control unit 11 is configured to receive an instruction (an instruction to execute downgrade) to return any history information displayed in the history display field R4 to a state immediately before or immediately after the execution of a process indicated by the history information. When any history information is specified and an instruction to execute downgrade is received, the control unit 11 is configured to return the intermediate prompt and the program code to a state immediately before (for example, immediately before an editing process is performed) or immediately after (for example, immediately after an editing process is performed) the process in the history information is executed. In this case, the control unit 11 returns the display contents of the application design screen to the intermediate prompt and the program code in a state immediately before or immediately after the process in the history information is executed. With this configuration, the state of the intermediate prompt and the program code can be returned to a desired state (a state of a desired version), and the editing process can be efficiently executed by repeatedly executing and redoing the editing of the intermediate prompt and the program code. The application design screen is not limited to the configuration shown in FIG. 7B. For example, the prompt wizard field R3 may be configured to be switched and displayed by selecting a menu item in the menu field R1, as in the GUI field R2. Also, the prompt wizard field R3 may be divided into a plurality of fields, and an intermediate prompt field I3 for the set menu item may be displayed in each prompt wizard field R3.
[0026] In the application design screen having the above-mentioned configuration, for example, when a user generates software (program code) using natural language via the prompt wizard field R3, the user inputs an overview prompt into the overview prompt field I2 or an intermediate prompt into the intermediate prompt field I3, and operates the Apply button B3 or B4. When a user generates software via a GUI provided in the GUI field R2, the user inputs the settings of each menu item via the GUI. When a user inputs program code, the user inputs the program code via an input field provided in the GUI field R2. For example, as shown in FIG. 13, the GUI field R2 is provided with an input field (display field) for program code, and is configured so that the program code can be input via the input field. Furthermore, when history information is displayed in the history display field R4, the user can revert the intermediate prompt and program code to any version by instructing to downgrade any history information.
[0027] The control unit 11 of the information processing device 10 determines whether or not an input of a summary prompt has been accepted via the summary prompt field I2 on the screen shown in Fig. 7B (S15), and if it is determined that an input of a summary prompt has been accepted (S15: YES), the process proceeds to step S20. If the control unit 11 determines that an input of a summary prompt has not been accepted (S15: NO), the control unit 11 determines whether or not an input of an intermediate prompt has been accepted via the intermediate prompt field I3 (S16), and if it is determined that an input of an intermediate prompt has been accepted (S16: YES), the process proceeds to step S48. If the control unit 11 determines that an input of an intermediate prompt has not been accepted (S16: NO), the control unit 11 determines whether or not an input of setting contents has been accepted via the GUI provided in the GUI field R2 (S17), and if it is determined that an input of setting contents has been accepted (S17: YES), the process proceeds to step S73. If the control unit 11 determines that the input of the setting contents has not been accepted via the GUI (S17: NO), it determines whether or not the input of the program code has been accepted via the GUI field R2 (S18), and if it determines that the input has been accepted (S18: YES), it proceeds to step S88. If the control unit 11 determines that the input of the program code has not been accepted (S18: NO), it determines whether or not the instruction to execute downgrade has been accepted (S19), and if it determines that the instruction has been accepted (S19: YES), it proceeds to step S102. If the control unit 11 determines that the instruction to execute downgrade has not been accepted (S19: NO), it returns to step S15.
[0028] When it is determined that the input of the overview prompt has been accepted (S15: YES), the control unit 11 accepts the input overview prompt and displays it in the overview prompt field I2 in the application design screen (S20). Here, the control unit 11 may accept the input of the overview prompt by text input via the input unit 14, or may accept the input of the overview prompt by image input by operating the image input button B1, or by voice input by operating the voice input button B2. Furthermore, the control unit 11 may accept the input of the overview prompt by various files or data such as text files, video files, pdf files, binary files, etc. Next, the control unit 11 determines whether the Apply button B3 has been operated (S21), and when it is determined that the Apply button B3 has not been operated (S21: NO), the process returns to step S20 and continues accepting the input of the overview prompt in the overview prompt field I2.
[0029] When the control unit 11 determines that the Apply button B3 has been operated (S21: YES), it generates an intermediate prompt based on the input summary prompt (S22). Here, the control unit 11 inputs the summary prompt input in the summary prompt field I2, specifically, the summary prompt displayed in the summary prompt field I2 at this point, to the natural language processing model M, and obtains an intermediate prompt that describes the detailed specification contents of the application to be generated in natural language by the natural language processing model M. The summary prompt includes text data and / or image data. The control unit 11 may input the summary prompt as it is to the natural language processing model M, or may input the summary prompt to the natural language processing model M after adding a message for controlling the output result from the natural language processing model M, such as "Please create a detailed specification document for software with the following contents" at the beginning of the summary prompt. Also, when the natural language processing model M is configured to be able to input an image and the input summary prompt includes an image, the control unit 11 inputs the summary prompt including the image to the natural language processing model M. In addition to inputting the image included in the summary prompt to the natural language processing model M as it is, the control unit 11 may generate text data from the image by an OCR (Optical Character Recognition) function and input the generated text data to the natural language processing model M. The intermediate prompt output by the natural language processing model M may include not only text data describing the specification contents of the application to be generated in natural language, but also image data (still images and videos) corresponding to the contents of the summary prompt. For example, the natural language processing model M may be configured to output a file such as image data (still images and videos) input as the summary prompt as is or after being partially processed. The natural language processing model M may also be configured to generate and output a file such as image data based on the contents of the summary prompt. By using such a natural language processing model M, for example, a screen design in an application can be generated from the contents of the summary prompt.
[0030] The control unit 11 displays the generated intermediate prompt in the intermediate prompt field I3 (S23). The control unit 11 displays, for example, an application design screen as shown in FIG. 8. The application design screen shown in FIG. 8 shows a state in which the prompt wizard field R3 is displayed on a large screen, and the screen switching button B5 in the screen of FIG. 8 is changed so as to accept an instruction to switch to a screen in which the GUI field R2 and the prompt wizard field R3 are displayed side by side. In the screen shown in FIG. 8, a summary prompt of "Please create an application with a member login function and a member-only blog function" is input in the summary prompt field I2, and intermediate prompts generated from the summary prompt are displayed in the intermediate prompt field I3 of each menu item. When inputting the summary prompt to the natural language processing model M, the control unit 11 instructs the output data to be output for each setting item (menu item). For example, the control unit 11 adds a message for controlling the output result from the natural language processing model M, such as "Please create a detailed specification for Data Schema (data structure)", to the summary prompt and then inputs it to the natural language processing model M. This allows the control unit 11 to obtain an intermediate prompt generated by the natural language processing model M for each menu item, and to display the obtained intermediate prompt in each intermediate prompt field I3.
[0031] The control unit 11 may also divide the output data output from the natural language processing model M by inputting the summary prompt to the natural language processing model M into each setting item (menu item) and display them in the respective intermediate prompt columns I3. For example, the control unit 11 may search for terms related to Data Schema in the output data from the natural language processing model M, extract contents related to Data Schema from the search results, and display the extracted contents in the intermediate prompt column I3 for Data Schema. Similarly, the control unit 11 may search for terms related to Screen Definition in the output data from the natural language processing model M, extract contents related to Screen Definition from the search results, and display the extracted contents in the intermediate prompt column I3 for Screen Definition. The control unit 11 may also search for terms related to Theme Color in the output data from the natural language processing model M, extract contents related to Theme Color from the search results, and display the extracted contents in the intermediate prompt column I3 for Theme Color. The control unit 11 may also search for terms related to Language in the output data from the natural language processing model M, extract content related to Language from the search results, and display the extracted content in the Language intermediate prompt field I3. The control unit 11 may then display the remaining content that was not extracted in the Others intermediate prompt field I3. Even in this configuration, an intermediate prompt generated from a summary prompt using the natural language processing model M is displayed in the intermediate prompt field I3 corresponding to each menu item.
[0032] The control unit 11 generates history information (generation history information of the intermediate prompt) indicating the contents of the generation process that generated the intermediate prompt from the summary prompt, adds version information (version number) to the generated history information, stores the generated history information in the storage unit 12, and displays the history information in the history display field R4 of the application design screen (S24). The screen shown in FIG. 8 displays history information including the input contents of the summary prompt and the date and time when the intermediate prompt was generated from the summary prompt. The history display field R4 has an uncommitted field R4b that displays history information in a state where the intermediate prompt and program code being created have not been confirmed (hereinafter referred to as an uncommitted state), and a committed field R4a that displays history information in a state where the intermediate prompt and program code being created have been confirmed (hereinafter referred to as a committed state). Here, since the generated intermediate prompt is in an uncommitted state, the control unit 11 displays the generation history information of the intermediate prompt in the uncommitted field R4b. The control unit 11 highlights the uncommitted state history information by underlining it, as shown in FIG. 8. Furthermore, the control unit 11 displays a Revert button for instructing to cancel (undo) the process in the uncommitted history information (here, the process of generating an intermediate prompt from a summary prompt) and a Commit button B6 for instructing to confirm the uncommitted intermediate prompt in the uncommitted column R4b. When the Revert button is operated, the control unit 11 returns the display contents of the summary prompt column I2, the intermediate prompt column I3, and the history display column R4 to the state before the process in the uncommitted history information was executed. This makes it possible to return the intermediate prompt and program code being created to the state before the process in the history information was executed. Note that when the Revert button is operated, the control unit 11 may keep the summary prompt input in the process indicated by the history information displayed, without returning the display contents of the summary prompt column I2 to the state before the process indicated by the history information was executed. In this case, it is not necessary to input a summary prompt again, and a new summary prompt can be input by editing the summary prompt that has already been input.When the Commit button B6 is operated, if the program code corresponding to the intermediate prompt displayed in the intermediate prompt column I3 has not been generated, the control unit 11 generates the program code and confirms the intermediate prompt and the program code here (sets them in a committed state). The control unit 11 moves the history information corresponding to the intermediate prompt and the program code in the committed state to the commit column R4a as shown in FIG. 10A, for example, and displays it. At this time, the control unit 11 ends the highlighting of the history information and displays it in the commit column R4a. The control unit 11 may also input the input contents of the summary prompt to the natural language processing model M, generate a summary of the input contents, and use the summary as the generation history information of the intermediate prompt. In the state shown in FIG. 8 (a state in which an intermediate prompt is generated from a summary prompt and displayed), it is possible to edit (add and delete) the summary in the summary prompt column I2, and the user visually checks the intermediate prompt, edits the summary prompt as necessary, and operates the Apply button B3 again.
[0033] In the state shown in FIG. 8, the control unit 11 judges whether an edit to the summary prompt displayed in the summary prompt field I2 has been accepted (S25). If it is judged that the edit has been accepted (S25: YES), the process returns to the process of step S20 and repeats the processes of steps S20 to S24. Specifically, the control unit 11 displays the edited summary prompt in the summary prompt field I2, and when the Apply button B3 is operated, the control unit 11 uses the natural language processing model M to generate an intermediate prompt from the edited summary prompt, displays the generated intermediate prompt in the intermediate prompt field I3, and displays history information of the intermediate prompt generation process in the uncommitted field R4b of the history display field R4. Here, since the intermediate prompt generated based on the previously input summary prompt is displayed in the intermediate prompt field I3, in step S22, the control unit 11 may generate a new intermediate prompt (an intermediate prompt corresponding to the edited summary prompt) by inputting the intermediate prompt being displayed in the intermediate prompt field I3 to the natural language processing model M in addition to the edited summary prompt. Furthermore, the control unit 11 may extract the difference (changes) between the summary prompt before and after editing, and generate a new intermediate prompt by inputting the changes to the summary prompt and the intermediate prompt being displayed in the intermediate prompt column I3 to the natural language processing model M. As a result, the display content in the intermediate prompt column I3 is updated to an intermediate prompt corresponding to the updated summary prompt, and the display content in the uncommitted column R4b is updated to history information related to the updated intermediate prompt.
[0034] In the above process, the control unit 11 displays an application design screen as shown in FIG. 9 on the display unit 15. In the screen shown in FIG. 9, the edited overview prompt is displayed in the overview prompt column I2, an intermediate prompt corresponding to the edited overview prompt is displayed in the intermediate prompt column I3, and the history information of the process that generated the new intermediate prompt is highlighted in the history display column R4 (uncommitted column R4b). In FIG. 9, the contents changed (added) by editing the overview prompt are highlighted by underlining in the intermediate prompt column I3 of the Screen Definition, but they do not have to be highlighted. In addition, the contents changed by editing may be highlighted for the edited overview prompt displayed in the overview prompt column I2. In this case, the user can easily understand the contents of the overview prompt that the user added and the contents of the intermediate prompt that were changed by editing the overview prompt. In the screen shown in FIG. 9, when the control unit 11 receives a cancel instruction for the uncommitted history information, the display contents of the overview prompt column I2, the intermediate prompt column I3, and the history display column R4 can be returned to the state before the process in the history information was executed.
[0035] 8 and 9, when the control unit 11 determines that editing of the summary prompt has not been accepted (S25: NO), it determines whether or not the Apply button B4 provided in association with the intermediate prompt field I3 has been operated (S26). When it determines that the Apply button B4 has been operated (S26: YES), the control unit 11 generates program code based on the intermediate prompt displayed in the intermediate prompt field I3 at this time (S27). Here, the control unit 11 generates text data in one natural language by associating each menu item with the intermediate prompt displayed in the intermediate prompt field I3 of each menu item, inputs the generated text data to the natural language processing model M, and acquires the program code of the application to be generated by the natural language processing model M. The control unit 11 may input the generated text data (intermediate prompt) as is to the natural language processing model M, or may add, for example, information on the format of the program to be generated (function name, argument and return value type information, etc.) or a message for controlling the output result from the natural language processing model M, such as "Please create program code for the application with the following content," to the beginning of the text data and then input it to the natural language processing model M. Furthermore, when the intermediate prompt includes not only text data but also image data, etc., the control unit 11 inputs the image data, etc. together with the text data to the natural language processing model M and acquires the program code from the natural language processing model M.
[0036] The control unit 11 executes a build process on the generated program code (S29). The build process is a process of analyzing whether or not there is a problem (error, bug, etc.) in the program code (source code), and if there is no problem, converting the program code into an executable file (executable file), and if there is a problem, outputting error information indicating the detected problem. The control unit 11 judges whether or not the build process was successful (S30), and if it judges that the build process has failed (S30: NO), for example, if error information has been output as a result of the build process, it outputs an error message notifying that the build process has failed (S31), and returns to the process of step S25. For example, the control unit 11 displays the error message on the application design screen, and the user edits the overview prompt being displayed in the overview prompt field I2 based on the error content. Thereby, if the control unit 11 accepts new edits to the overview prompt (S25: YES), it repeats the processes of steps S20 to S24.
[0037] When it is determined that the build process is successful (S30: YES), the control unit 11 displays the contents (setting information) set for each menu item in the GUI field R2 of the application design screen based on the generated program code (S32). The control unit 11 displays, for example, an application design screen (GUI field R2) as shown in FIG. 11 or FIG. 12. The control unit 11 displays, in the GUI field R2, the setting contents of the menu item selected via the menu field R1. FIG. 11 shows an example of the display of the GUI field R2 when the menu item "Theme" is selected, and FIG. 12 shows an example of the display of the GUI field R2 when the menu item "Screen" is selected.
[0038] Next, the control unit 11 executes a deploy process on the executable file generated from the program code by the build process (S33). The deploy process is a process of storing the executable file in an environment (device) in which the executable file is to be operated, and running the application by executing the executable file. By performing the deploy process, the control unit 11 can display a screen preview of the application in the GUI field R2, for example, as shown in FIG. 11. Thereafter, the control unit 11 generates history information by associating the program code generated in step S27, the intermediate prompt used to generate the program code, and version information assigned to the intermediate prompt (for example, a version number, specifically, a version number assigned to the history information in step S24), and stores the history information in, for example, the storage unit 12 (S34). This allows the intermediate prompt and the program code to be associated with the version information of the intermediate prompt, and when an instruction to execute downgrade is received based on the history information displayed in the history display field R4 (commit field R4a), for example, the control unit 11 can restore the intermediate prompt and program code of the specified version. When the control unit 11 generates program code for the application to be generated for the first time, the control unit 11 stores the generated program code in a file with a preset file name or a file name generated according to a preset rule. When program code has already been generated for the application to be generated, the control unit 11 overwrites the generated program code in the already generated file. When the control unit 11 stores intermediate prompts, the control unit 11 stores the menu items Data Schema, Screen Definition, Theme Color, Language, and Others in association with the intermediate prompts displayed in the intermediate prompt columns I3.
[0039] 8 and 9, if it is determined that the Apply button B4 provided in association with the intermediate prompt column I3 has not been operated (S26: NO), the control unit 11 proceeds to step S35 and determines whether or not the Commit button B6 in the uncommitted column R4b has been operated (S35). If it is determined that the Commit button B6 has not been operated (S35: NO), the control unit 11 returns to the process of step S25 and waits until an edit to the summary prompt is accepted, the Apply button B4 is operated, or the Commit button B6 is operated.
[0040] When it is determined that the Commit button B6 has been operated on the screens of Figs. 8 and 9 (S35: YES), the control unit 11 determines whether the program code has already been generated by operating the Apply button B4, a build process has been executed on the generated program code, and whether the executed build process has been successful (S36). When it is determined that the build process has not been executed (S36: NO), the control unit 11 executes the same processes as steps S27 to S34 (S37 to S44). That is, when the Apply button B4 or the Commit button B6 has been operated on the screens of Figs. 8 and 9, the control unit 11 executes a process of generating program code from the intermediate prompt displayed in the intermediate prompt field I3 at that time, and a build process and a deploy process for the program code. Note that when generating program code, if the program code has already been generated, the control unit 11 may generate new program code by inputting the already generated program code to the natural language processing model M in addition to the intermediate prompt displayed in the intermediate prompt field I3. In addition, when program code has already been generated, the control unit 11 may extract the difference between the intermediate prompt used to generate the already generated program code (the intermediate prompt of the previous version) and the intermediate prompt displayed in the intermediate prompt column I3 at this point (the intermediate prompt of the latest version), and generate the latest version of the program code by inputting the extracted difference and the already generated program code (the program code of the previous version) into the natural language processing model M.
[0041] When the control unit 11 determines that the build process has been executed and succeeded (S36: YES), or after the process of step S44, it confirms the intermediate prompt displayed in the intermediate prompt column I3 at this time and the program code generated from this intermediate prompt (S45). That is, the control unit 11 commits the intermediate prompt and the program code stored in the storage unit 12 at step S34 or step S44. Therefore, when the Commit button B6 in the uncommitted column R4b is operated, the intermediate prompt and the program code at this time are once confirmed. Then, the control unit 11 updates the prompt wizard column R3 of the application design screen being displayed (S46). For example, as shown in FIG. 10A, the control unit 11 updates the summary prompt column I2 to an empty state (Blank), ends the highlighting of the history information displayed in the uncommitted column R4b, and moves it to the committed column R4a. In this case, the uncommitted column R4b is deleted. 10A, it is possible to input a new overview prompt to the overview prompt field I2 and edit an intermediate prompt to the intermediate prompt field I3. The user visually checks the intermediate prompt displayed in the intermediate prompt field I3 and inputs a new overview prompt or edits the intermediate prompt as necessary.
[0042] The control unit 11 judges whether an instruction to end the program code generation process has been received (S47). For example, the control unit 11 judges whether an instruction to end the design support application AP has been received via the input unit 14. If the control unit 11 judges that an instruction to end the design support application AP has not been received (S47: NO), the control unit 11 returns to the process of step S15, and executes the processes of steps S20 to S46 every time a summary prompt is input or edited via the summary prompt field I2. As a result, every time a summary prompt is input or edited, an intermediate prompt is generated based on the input or edited summary prompt, and program code is generated based on the generated intermediate prompt. If the control unit 11 judges that an instruction to end the process has been received (S47: YES), the control unit 11 ends the series of processes.
[0043] When it is determined in step S16 that an input of an intermediate prompt has been accepted via the intermediate prompt field I3 (S16: YES), the control unit 11 accepts the input intermediate prompt and displays it in the intermediate prompt field I3 in the application design screen (S48). If an intermediate prompt is already displayed in the intermediate prompt field I3, the control unit 11 accepts editing of the intermediate prompt and displays the accepted edited intermediate prompt. The control unit 11 is configured to accept input of the intermediate prompt by text input, voice input, or image input via the input unit 14. The control unit 11 is also configured to accept an insertion position designation by clicking with a mouse on any position of the displayed intermediate prompt, and to accept editing of the intermediate prompt by accepting contents to be inserted by text input, voice input, or image input. In input and editing of the intermediate prompt, the control unit 11 may also be configured to accept data of any type or format, such as a text file, an image file, a video file, a pdf file, or a binary file.
[0044] The control unit 11 adds a version number to the editing history information indicating the input contents or edited contents of the intermediate prompt, stores the version number in the storage unit 12, and displays the editing history information in the uncommitted column R4b of the application design screen (S49). The control unit 11 displays, for example, an application design screen as shown in FIG. 10B. In the screen of FIG. 10B, the edited intermediate prompt is displayed in the intermediate prompt column I3 of Theme Color, and the editing history information of the intermediate prompt and the Commit button B6 are displayed in the uncommitted column R4b of the history display column R4. The editing history information of the intermediate prompt includes the name of the edited menu item (Theme in FIG. 10B) and the date and time of editing. In the screen of FIG. 10B as well, the uncommitted column R4b can accept a cancellation instruction for the history information in the uncommitted state via the Revert button, and when the Revert button is operated, the control unit 11 can return the display contents of the intermediate prompt column I3 and the history display column R4 to the state before the execution of the process in the history information displayed in the uncommitted column R4b. Furthermore, the control unit 11 may input the input contents or edited contents of the intermediate prompt to the natural language processing model M, generate a summary of the input contents or edited contents, and use the summary as the editing history information of the intermediate prompt.
[0045] 10B (a state in which an intermediate prompt is being input or edited), it is possible to edit (add and delete) the intermediate prompt in the intermediate prompt column I3, and the user visually checks the intermediate prompt and edits the intermediate prompt as necessary. The control unit 11 determines whether or not the edit for the intermediate prompt has been accepted (S50), and if it determines that it has been accepted (S50: YES), it returns to the processing of step S48 and repeats the processing of steps S48 to S50. As a result, every time an edit is made to an intermediate prompt, the control unit 11 updates the display content of the intermediate prompt column I3 to the edited intermediate prompt, and updates the display content of the uncommitted column R4b to history information related to the updated intermediate prompt.
[0046] In the screen shown in FIG. 10B, when the control unit 11 determines that editing of the intermediate prompt has not been accepted (S50: NO), it determines whether or not the Apply button B4 provided in association with the intermediate prompt column I3 has been operated (S51), and when it determines that the Apply button B4 has been operated (S51: YES), it executes the same processing as steps S27 to S34 (S52 to S59). That is, when the Apply button B4 is operated in the screen of FIG. 10B, the control unit 11 performs a process of generating a program code from the intermediate prompt displayed in the intermediate prompt column I3 at this time, and a build process and a deploy process for the program code. In addition, in step S52, when the program code has already been generated, the control unit 11 may generate new program code by inputting the generated program code to the natural language processing model M in addition to the intermediate prompt being displayed in the intermediate prompt column I3. In addition, the control unit 11 may extract a difference between the intermediate prompt before and after editing, and input the extracted difference and the generated program code to the natural language processing model M to generate the latest version of the program code. Furthermore, in step S59, the control unit 11 generates history information by associating the program code generated in step S52, the edited intermediate prompt input in step S48, and the version information assigned to this intermediate prompt, and stores the history information, for example, in the memory unit 12 (S59).
[0047] 10B, the control unit 11 determines whether the Apply button B4 provided in association with the intermediate prompt field I3 has been operated (S51: NO), the control unit 11 proceeds to step S60 and determines whether the Commit button B6 in the uncommitted field R4b on the screen has been operated (S60). If the control unit 11 determines that the Commit button B6 has not been operated (S60: NO), the control unit 11 returns to the process of step S50 and waits until an edit to the intermediate prompt is accepted, the Apply button B4 is operated, or the Commit button B6 is operated.
[0048] When it is determined that the Commit button B6 has been operated on the screen of Fig. 10B (S60: YES), the control unit 11 determines whether or not the program code has already been generated by operating the Apply button B4, a build process has been executed on the generated program code, and the executed build process has been successful (S61). When it is determined that a build process has not been executed (S61: NO), the control unit 11 executes the same processes as steps S52 to S59 (S62 to S69). That is, when the Apply button B4 or the Commit button B6 has been operated on the screen of Fig. 10B, the control unit 11 executes a process of generating program code from the intermediate prompt displayed in the intermediate prompt column I3 at that time, and a build process and a deploy process on the program code.
[0049] When the control unit 11 determines that the build process has been executed and succeeded (S61: YES), or after the process of step S69, it confirms the intermediate prompt displayed in the intermediate prompt column I3 at this time and the program code generated from this intermediate prompt (S70). Therefore, when the Commit button B6 in the uncommitted column R4b is operated, the intermediate prompt and the program code at this time are in a committed state. Then, the control unit 11 updates the prompt wizard column R3 of the application design screen being displayed (S71). Step S71 is the same process as step S46, and the prompt wizard column R3 is updated to the state shown in FIG. 11 and FIG. 12. Specifically, the control unit 11 ends the highlighting of the history information being displayed in the uncommitted column R4b, moves it to the committed column R4a, and deletes the uncommitted column R4b. The control unit 11 determines whether an instruction to end the program code generation process has been received (S72), and if it determines that an instruction has not been received (S72: NO), the control unit 11 returns to the process of step S15 and executes the processes of steps S48 to S71 every time an intermediate prompt is input or edited via the intermediate prompt field I3. As a result, every time an intermediate prompt is input or edited, program code is generated based on the input or edited intermediate prompt. If the control unit 11 determines that an instruction to end has been received (S72: YES), the control unit 11 ends the series of processes.
[0050] When it is determined in step S17 that the input of the setting contents has been accepted via the GUI provided in the GUI field R2 (S17: YES), the control unit 11 accepts the input setting contents and displays them in the GUI field R2 in the application design screen (S73). If the setting contents are already displayed in the GUI field R2, the control unit 11 accepts editing of the displayed setting contents and displays the accepted edited setting contents. The GUI field R2 displays the setting contents of the menu item selected via the menu field R1. FIG. 11 shows the GUI field R2 in which the setting contents of the Theme menu item are displayed, and the setting contents for each color of the base color (background color), main color, text color, and accent color are displayed as theme colors in the application. In the example of FIG. 11, the control unit 11 displays, as the setting contents of each color, the color code assigned to each set color, a color palette B7 displaying each color, and a preview of the screen using each color in the GUI field R2. The color palette B7 is configured to accept changes to the setting contents of each color. For example, when any of the color palettes B7 is operated (e.g., clicked with a mouse), the control unit 11 of the information processing device 10 displays a list of selectable colors, and when the selection of any of the colors is accepted, the control unit 11 updates the setting contents (the setting color of each color) to the selected color. When the setting contents of any of the colors are changed, the control unit 11 displays the color code and color palette B7 of the changed color, and a preview of the screen using the changed color. The GUI field R2 in the screen of FIG. 11 is provided with an Apply button B8 for instructing application (reflection) of the changed contents via the color palette B7. When the user changes the setting contents of any of the colors via the color palette B7 in the screen of FIG. 11 and then updates (applies) them to the changed contents, the user operates the Apply button B8.
[0051] 12 and 13 show the GUI field R2 in which the setting contents of the menu items of Screen are displayed, and the setting contents for the display screen in the application are displayed. The GUI field R2 shown in FIG. 12 displays a screen transition diagram (routing), and for each screen, the name of the screen and the ID assigned to the screen are displayed. In addition, the GUI field R2 in FIG. 12 is provided with an edit button B10 for instructing the execution of an editing process for each screen, and a delete button B11 for instructing the deletion of each screen, in association with each screen. In addition, the GUI field R2 in FIG. 12 is provided with an Apply button B9 for instructing the application (reflection) of the deletion of the screen corresponding to the operated delete button B11 when the delete button B11 corresponding to any screen is operated. After operating any delete button B11 in the screen in FIG. 12, the user operates the Apply button B9 when updating (applying) the operation contents.
[0052] When the edit button B10 of any screen is operated in the GUI field R2 of FIG. 12, the control unit 11 of the information processing device 10 displays the setting contents for the screen corresponding to the operated edit button B10, as shown in FIG. 13. The GUI field R2 of FIG. 13 shows a display example when the edit button B10 corresponding to the Home Screen is operated in the GUI field R2 of FIG. 12. The GUI field R2 (preview field) of FIG. 13 displays the name of the screen, the source code (program code) related to the screen, and a preview of the screen. The GUI field R2 of FIG. 13 is configured to accept edits (changes) to the program code being displayed, and when the control unit 11 accepts edits to the program code, it displays the edited contents (input contents) in the GUI field R2. In FIG. 13, the control unit 11 highlights the edited contents by underlining them. The GUI field R2 of FIG. 13 is provided with an Apply button B12 for instructing application (reflection) of the edited contents to the program code. After editing the program code on the screen of FIG. 13, the user operates the Apply button B12 when updating (applying) the edited content.
[0053] 11 to 13 show the state where the program code is edited via the GUI field R2 for the menu items Theme and Screen, but the program code can also be edited via the GUI field R2 for the menu items Data, Language and Others. For example, for the menu item Data, information about the set database (e.g., the name of the data field, the type of data stored in each data field, the number of digits and the amount of data, etc.) is displayed in the GUI field R2, and each piece of information can be edited. Also, for the menu item Language, the correspondence between each language (translation) is displayed in the GUI field R2 as information about the set language, and each piece of information can be edited.
[0054] The control unit 11 judges whether the Apply buttons B8, B9 provided in the GUI field R2 have been operated on the screen shown in FIG. 11 or FIG. 12 (S74), and if it is judged that they have not been operated (S74: NO), the process returns to step S73, and continues to accept input or editing of the setting contents via the GUI. If it is judged that the Apply buttons B8, B9 provided in the GUI field R2 have been operated (S74: YES), the control unit 11 generates a program code based on the setting contents of each menu item displayed in the GUI field R2 at this time point (S75). For example, the control unit 11 updates the program code already generated at this time point based on the setting contents of each menu item displayed in the GUI field R2 at this time point (the setting contents after editing input or editing via the GUI field R2) to generate a new program code. For example, the control unit 11 rewrites various setting values included in the generated program code based on the setting contents of each menu item. The control unit 11 may also generate a new program code by inputting the edited setting contents and the program code already generated at this time point into the natural language processing model M. Furthermore, the control unit 11 may generate an intermediate prompt corresponding to the edited setting content by inputting the edited setting content and the intermediate prompt currently being displayed in the intermediate prompt field I3 to the natural language processing model M, and may generate new program code by inputting the intermediate prompt generated for each menu item to the natural language processing model M. At this time, the control unit 11 may input the generated intermediate prompt and the program code already generated at this point to the natural language processing model M to generate new program code, or may extract the difference (changes) before and after the generation of the intermediate prompt and input the extracted difference and the generated program code to the natural language processing model M to generate new program code.
[0055] After that, the control unit 11 executes the same processes as steps S29 to S31 (S77 to S79). After the process of step S79, the control unit 11 returns to the process of step S73. When it is determined that the build process is successful (S78: YES), the control unit 11 generates an intermediate prompt corresponding to the program code generated in step S75 from the program code (updated program code) and updates the intermediate prompt displayed in the intermediate prompt column I3 (S80). For example, the control unit 11 extracts a difference (change contents) between the program code before and after the update, and inputs the extracted difference and the intermediate prompt corresponding to the program code before the update to the natural language processing model M, thereby generating an intermediate prompt corresponding to the updated program code. Then, the control unit 11 displays the generated intermediate prompt corresponding to the updated program code in the intermediate prompt column I3. Note that the intermediate prompt corresponding to the updated program code is not limited to the configuration in which it is generated using the natural language processing model M. For example, the control unit 11 registers a partial intermediate prompt corresponding to the change contents in association with the change contents to the program code. The control unit 11 may then identify a partial intermediate prompt that corresponds to the difference (changes) between the program code before the update and the program code after the update, and generate an intermediate prompt that corresponds to the updated program code by adding the identified partial intermediate prompt to the intermediate prompt that corresponds to the program code before the update.
[0056] The control unit 11 adds a version number to update history information indicating the generated contents (update contents) of the intermediate prompt corresponding to the updated program code, stores the update history information in the storage unit 12, and displays the update history information in the uncommitted column R4b of the application design screen (S81). Then, the control unit 11 executes the same processes as steps S33 to S34 (S82 to S83). In step S83, the control unit 11 generates history information by associating the program code generated in step S75, the updated intermediate prompt generated in step S80, and the version number assigned to the intermediate prompt, and stores the history information in the storage unit 12. The control unit 11 determines whether the Commit button B6 in the uncommitted column R4b has been operated (S84). When it is determined that the Commit button B6 has not been operated (S84: NO), the control unit 11 returns to the process of step S73, and each time an edit of the setting contents is accepted via the GUI and the Apply buttons B8, B9 are operated, the control unit 11 performs a process of generating (updating) program code from the setting contents displayed in the GUI column R2, and a build process and a deploy process for the program code. The control unit 11 also performs a process of generating an intermediate prompt corresponding to the updated program code, and displays update history information of the generated intermediate prompt in the uncommitted column R4b.
[0057] When it is determined that the Commit button B6 has been operated (S84: YES), the control unit 11 confirms the intermediate prompt displayed in the intermediate prompt field I3 at this time and the program code corresponding to this intermediate prompt (S85). Then, the control unit 11 updates the prompt wizard field R3 of the application design screen being displayed (S86). Step S86 is the same process as step S46. The control unit 11 determines whether an instruction to end the program code generation process has been received (S87), and when it is determined that the instruction has not been received (S87: NO), the control unit 11 returns to the process of step S15, and executes the processes of steps S73 to S86 every time the input or editing of the setting contents is received via the GUI. As a result, every time the setting contents are input or changed via the GUI, the program code is generated or updated based on the setting contents of each menu item that has been input or changed, and an intermediate prompt is generated based on the generated or updated program code. When it is determined that an instruction to end has been received (S87: YES), the control unit 11 ends the series of processes.
[0058] When it is determined in step S18 that the input of the program code has been accepted via the GUI field R2 (S18: YES), the control unit 11 accepts the input program code and displays it in the GUI field R2 in the application design screen (S88). When the program code is already displayed in the GUI field R2, the control unit 11 accepts editing of the displayed program code and displays the accepted edited program code. For example, as shown in FIG. 13, the control unit 11 updates the program code displayed in the GUI field R2 to the edited program code. The control unit 11 determines whether the Apply button B12 provided in the GUI field R2 has been operated on the screen shown in FIG. 13 (S89), and if it determines that it has not been operated (S89: NO), the control unit 11 returns to the process of step S88 and continues to accept the input or editing of the program code via the GUI field R2. If it determines that the Apply button B12 provided in the GUI field R2 has been operated (S89: YES), the control unit 11 executes the same processes as steps S77 to S81 (S90 to S94). In step S90, the control unit 11 executes a build process on the program code (updated program code) input or edited via the GUI field R2 in step S88. In step S93, the control unit 11 generates an intermediate prompt corresponding to the updated program code based on the updated program code. Here, the control unit 11 regards the edited content of the program code as the difference (change content) before and after the update, and generates an intermediate prompt corresponding to the updated program code by inputting this difference and an intermediate prompt corresponding to the program code before the update to the natural language processing model M. Here again, when the change content of the program code is associated with a partial intermediate prompt corresponding to this change content, the control unit 11 may identify a partial intermediate prompt corresponding to the difference (change content) between the program code before and after the update, and add the identified partial intermediate prompt to the intermediate prompt corresponding to the program code before the update, thereby generating an intermediate prompt corresponding to the updated program code.Furthermore, in step S94, the control unit 11 adds a version number to the update history information of the intermediate prompt corresponding to the updated program code, stores the update history information in the storage unit 12, and also displays the update history information in the uncommitted column R4b.
[0059] Next, the control unit 11 updates the display contents (setting contents) of each menu item in the GUI field R2 based on the updated program code (S95). As a result, the display contents of each menu item in the GUI field R2 are changed to contents that correspond to the edited contents of the program code edited via the GUI field R2. Thereafter, the control unit 11 executes the same processes as steps S82 to S86 (S96 to S100). In addition, in step S97, the control unit 11 generates history information by associating the updated program code received in step S88, the intermediate prompt corresponding to the updated program code generated in step S93, and the version number assigned to this intermediate prompt, and stores the history information in the storage unit 12. Here, too, the control unit 11 may input the program code before and after editing to the natural language processing model M, for example, generate a summary of the edited contents of the program code, and use the summary as the editing history information of the program code. When the control unit 11 determines that the Commit button B6 has not been operated (S98: NO), the control unit 11 returns to the process of step S88, and performs build and deploy processes on the input or changed program code each time the Apply button B12 is operated after accepting edits to the program code. The control unit 11 also performs a process of generating an intermediate prompt corresponding to the updated program code, and displays update history information of the generated intermediate prompt in the uncommitted column R4b.
[0060] The control unit 11 determines whether an instruction to end the program code generation process has been received (S101), and if it determines that an instruction has not been received (S101: NO), the process returns to step S15, and executes steps S88 to S100 each time input or editing of program code is received via the GUI field R2. As a result, each time program code is input or edited, an intermediate prompt is generated based on the input or changed program code. If the control unit 11 determines that an instruction to end has been received (S101: YES), the process ends.
[0061] When it is determined in step S19 that the instruction to execute downgrade has been received (S19: YES), the control unit 11 receives the version information (version number) to be downgraded (S102). For example, the control unit 11 is configured to receive the instruction to execute downgrade based on the history information displayed in the history display field R4 (commit field R4a) of the prompt wizard field R3, and identifies the version information of the history information for which the execution of downgrade has been instructed. The control unit 11 reads out the intermediate prompt and the program code of the identified version information from the storage unit 12 (S103), executes a build process on the read program code (S104), and generates an executable file. Next, the control unit 11 updates the prompt wizard field R3 based on the read intermediate prompt (S106). Here, the control unit 11 displays the read intermediate prompt in the intermediate prompt field I3 of the prompt wizard field R3, and displays the history information up to the version for which the execution of downgrade has been instructed in the commit field R4a.
[0062] Next, the control unit 11 updates the GUI field R2 based on the program code read in step S103 (S107). Here, the control unit 11 displays the setting contents and program code for each menu item in the GUI field R2 based on the read program code. Thereafter, the control unit 11 executes a deploy process for the executable file generated by the build process in step S104 (S108). This causes an application design screen based on the intermediate prompt and program code corresponding to the history information of the version instructed to perform downgrade to be displayed. Thereafter, the control unit 11 proceeds to step S101, and if it determines that an instruction to end the program code generation process has not been received (S101: NO), it returns to the process of step S15 and executes the processes of steps S102 to S108 every time an instruction to perform downgrade is received. If the control unit 11 determines that an instruction to end the program code generation process has been received (S101: YES), it ends the series of processes.
[0063] According to the above-mentioned process, in this embodiment, software (program code) can be generated based on prompts (summary prompts and intermediate prompts) input by natural language and / or images, etc. Also, the prompts can be edited by natural language and / or images, etc., and the program code can be modified by editing the prompts. Note that the prompts can be input and edited by text input, image input, voice input, etc. Therefore, even a user who does not have specialized knowledge such as software design skills or development skills can design and develop any software. Also, in this embodiment, an overview of an application is accepted as a summary prompt, an intermediate prompt indicating the detailed specification contents of the application is generated from the summary prompt, and program code is generated from the intermediate prompt. It is conceivable to generate program code directly from the summary prompt, but in this case, it is assumed that program code not intended by the user will be generated, and it is expected that the number of reworks such as correcting the program code will increase. In contrast, in this embodiment, program code is generated from an intermediate prompt generated from the summary prompt, so that program code intended by the user can be generated with fewer corrections. Also, the intermediate prompt used to generate the program code becomes a detailed specification of the application, so that the work process of creating a software specification separately from the generation of the program code can be reduced. In this embodiment, the process of generating program code based on a prompt has been described, but the object to be generated may not only be program code for implementing an application, but also a configuration file (settings file) in the application.
[0064] In this embodiment, the process of generating an intermediate prompt from a summary prompt using the natural language processing model M and the process of generating a program code from an intermediate prompt using the natural language processing model M are not limited to a configuration in which the information processing device 10 locally performs the process. For example, the process using the natural language processing model M may be configured to be executed by a server that provides the natural language processing model M. For example, the information processing device 10 can be configured to transmit a summary prompt input via the prompt wizard field R3 to a server and receive an intermediate prompt generated from the summary prompt at the server. Furthermore, the information processing device 10 can be configured to transmit an intermediate prompt displayed in the prompt wizard field R3 to a server and receive a program code generated from the intermediate prompt at the server. Furthermore, the process of generating new program code from setting information of the program code changed via the GUI using the natural language processing model M, the process of generating an intermediate prompt corresponding to the changed setting contents from setting information of the program code changed via the GUI, and the process of generating an intermediate prompt corresponding to the program code from the updated program code are also not limited to a configuration in which the information processing device 10 locally performs the process.
[0065] (Embodiment 2) In the above-mentioned first embodiment, an information processing device will be described that, when the build process fails, corrects an error portion by using a natural language processing model M. The information processing device of this embodiment has a configuration similar to that of the information processing device 10 of the first embodiment shown in FIG. 1, and therefore a description of the configuration will be omitted.
[0066] Fig. 14 is a flowchart showing an example of a program code generation process procedure of the second embodiment. The process shown in Fig. 14 is obtained by adding steps S111 to S114 between steps S30 and S31, between steps S40 and S41, between steps S55 and S56, between steps S65 and S66, between steps S78 and S79, and between steps S91 and S92 in the process shown in Fig. 2 to Fig. 6. Explanations of steps that are the same as those in Fig. 2 to Fig. 6 will be omitted. In Fig. 14, illustrations of steps other than steps S30 to S31, S40 to S41, S55 to S56, S65 to S66, S78 to S79, and S91 to S92 are omitted.
[0067] When the control unit 11 of the information processing device 10 determines that the build process has failed in any of steps S30, S40, S55, S65, S78, and S91 (NO), it attempts to correct the program code (S111). For example, the control unit 11 inputs the program code that has been built and error information (contents of the problem contained in the program code) output by the build process into the natural language processing model M, thereby acquiring the corrected program code from the natural language processing model M. Then, the control unit 11 executes the build process again (executes the rebuild process) on the corrected program code (S112). The control unit 11 determines whether the re-executed build process was successful (S113), and when it determines that the build process has failed (S113: NO), it determines whether the number of attempts to correct the program code at this point is equal to or greater than a predetermined number (e.g., 5 times, 10 times, etc.) (S114). When it is determined that the number of attempts to correct the program code is less than the predetermined number (S114: NO), the control unit 11 returns to step S111 and repeats the processes of steps S111 to S114. Note that in step S111, the control unit 11 may input the most recently generated corrected program code and error information generated in the build process performed on this program code to the natural language processing model M, thereby acquiring a further corrected program code.
[0068] If it is determined that the build process is successful (S113: YES), the control unit 11 proceeds to any of steps S32, S42, S57, S67, S80, and S93, and executes the processes of steps S32, S42, S57, S67, S80, and S93 and subsequent steps for the program code that has been successfully built. On the other hand, if it is determined that the number of attempts to correct the program code is equal to or greater than a predetermined number (S114: YES), the control unit 11 proceeds to steps S31, S41, S56, S66, S79, and S92, and outputs an error message notifying that the build process has failed and that the program code could not be corrected. After that, the control unit 11 proceeds to steps S25, S50, S73, and S88.
[0069] According to the above-described process, in this embodiment, when a build process fails due to some problem in the program code generated based on the intermediate prompts or the like, the natural language processing model M can be used to attempt to correct the program code. The control unit 11 can attempt to correct the program code multiple times, up to a predetermined number of times. If the problem is not resolved and the build process fails even after a predetermined number of attempts to correct the program code, an error message is output, and the user can redo the generation of the program code by editing the overview prompt, editing the intermediate prompt, editing (changing) the setting contents via a GUI, or editing the program.
[0070] In this embodiment, the processing is the same as that in the first embodiment, except for the processing of attempting to correct the program code using the natural language processing model M when the build processing fails, and the same effects as those in the first embodiment can be obtained. Furthermore, in this embodiment, since the program code is attempted to be corrected using the natural language processing model M, problems (errors, bugs, etc.) that can be corrected using the natural language processing model M can be automatically resolved. This reduces the operational burden on the user. The modified examples described as appropriate in the above-mentioned first embodiment can also be applied to this embodiment.
[0071] (Embodiment 3) An information processing device configured to interactively accept input of a summary prompt in the above-mentioned embodiment 1 will be described. The information processing device of this embodiment has a configuration similar to that of the information processing device 10 of embodiment 1 shown in Fig. 1, so a description of the configuration will be omitted.
[0072] FIG. 15 is an explanatory diagram showing a modified example of the application design screen. In addition to the same configuration as the screens in FIG. 8 to FIG. 10B, the application design screen shown in FIG. 15 has a summary prompt history field R5 that displays the input history of the summary prompt above the summary prompt field I2 in the prompt wizard field R3. In the screen shown in FIG. 15, when a summary prompt is input in the summary prompt field I2 and the Apply button B3 is operated, an intermediate prompt is generated from the summary prompt and displayed in the intermediate prompt field I3, as in the first embodiment, and the generation history of the intermediate prompt is displayed in the history display field R4 (uncommitted field R4b). In this embodiment, the input summary prompt is displayed in the summary prompt history field R5 and deleted from the summary prompt field I2. When a summary prompt is displayed in the summary prompt history field R5, dialogue information that prompts the user to input information about the summary prompt to be further input is displayed in the summary prompt history field R5, and the user inputs a new summary prompt according to the displayed dialogue information.
[0073] Fig. 16 is a flowchart showing an example of a program code generation processing procedure according to the third embodiment. The processing shown in Fig. 16 is obtained by adding steps S121 to S124 instead of step S25 in the processing shown in Figs. 2 to 6. Explanations of the same steps as in Figs. 2 to 6 will be omitted. Note that steps other than steps S14 to S15 and steps S20 to S24 in Figs. 2 to 6 are omitted in Fig. 16.
[0074] When the control unit 11 of the information processing device 10 of this embodiment determines in step S21 that the Apply button B3 has been operated (S21: YES), it executes the processes of steps S22 to S24 and displays an application design screen as shown in Fig. 8. Then, the control unit 11 displays the summary prompt inputted in the summary prompt field I2 in the summary prompt history field R5 (S121). Note that the control unit 11 erases the summary prompt that has been displayed (moved) to the summary prompt history field R5 from the summary prompt field I2.
[0075] Next, the control unit 11 generates dialogue information that prompts the user to take the next action (for example, input of a new summary prompt) based on the summary prompt moved to the summary prompt history column R5 (S122). For example, the control unit 11 inputs the summary prompt, or the summary prompt and the intermediate prompt displayed in the intermediate prompt column I3, to the natural language processing model M, and obtains dialogue information in which the content of the utterance to the user is described in natural language by the natural language processing model M. The control unit 11 may input the summary prompt, or the summary prompt and the intermediate prompt, to the natural language processing model M as is, or may input the summary prompt and the intermediate prompt to the natural language processing model M after adding a message for controlling the output result from the natural language processing model M, such as "Please create a message indicating what the user should do next" at the beginning. The dialogue information here may include, in addition to the request to the user, a question about the summary prompt, an instruction to execute the operation to be performed by the user next (for example, the operation of the Apply button B4 or the Commit button B6), and the like. The control unit 11 displays the generated dialogue information in the summary prompt history column R5 (S123). 15, the message "A specification (intermediate prompt) has been generated. Please let us know if any corrections are required" is displayed as the dialogue information. Note that the dialogue information displayed in the summary prompt history field R5 may be notified to the user by voice output, for example, if the information processing device 10 has a voice output function using a speaker.
[0076] The user checks the dialogue information displayed in the summary prompt history field R5, and inputs a new summary prompt as necessary. The control unit 11 determines whether or not input of a new summary prompt has been accepted via the summary prompt field I2 (S124), and if it is determined that input of a new summary prompt has been accepted (S124: YES), the process proceeds to step S20. Then, the control unit 11 executes the processes of steps S20 to S24 and S121 to S123 for the new summary prompt. If it is determined that input of a new summary prompt has not been accepted (S124: NO), the control unit 11 shifts the process to step S26, and executes the processes from step S26 onwards.
[0077] According to the above-described process, in this embodiment, when the user inputs a summary prompt, the user can input the summary prompt in the form of a response to the dialogue information displayed in the summary prompt history field R5, thereby reducing the operational burden on the user who inputs the summary prompt. In this embodiment, the dialogue information generated by the natural language processing model M is displayed in response to the summary prompt input by the user, but a message such as a hint regarding the input of the summary prompt may be displayed in the summary prompt history field R5 before the user inputs the summary prompt. In this case, even if the user does not know what kind of summary prompt to input, the user can input the summary prompt by following the message displayed in the summary prompt history field R5.
[0078] In this embodiment, the dialogue information displayed in the summary prompt history field R5 is not limited to the configuration in which it is generated using the natural language processing model M. For example, dialogue information may be registered in association with a keyword, and dialogue information corresponding to a keyword included in the summary prompt input by the user may be identified as dialogue information to be provided to the user.
[0079] In this embodiment, when a summary prompt is input, the process is the same as that of the first embodiment except that the input summary prompt and the dialogue information generated from this summary prompt are displayed in the summary prompt history field R5, and the same effect as that of the first embodiment can be obtained. In this embodiment, the summary prompt can be input in the form of a response to the dialogue information displayed in the summary prompt history field R5, so that the operational burden of the user who inputs the summary prompt can be reduced. In addition, even a user who is unfamiliar with the input operation of a prompt to the natural language processing model M can input an appropriate summary prompt, and as a result, it is possible to generate a highly accurate intermediate prompt and a highly accurate program code. The configuration of this embodiment can be applied to the information processing device 10 of the second embodiment, and even when applied to the information processing device 10 of the second embodiment, the same process is possible and the same effect can be obtained. In addition, the modified examples described appropriately in the above-mentioned first and second embodiments can be applied to this embodiment as well.
[0080] The matters described in each of the above embodiments can be combined with each other. In addition, the independent claims and dependent claims described in the claims can be combined with each other in any and all combinations regardless of the citation format. Furthermore, the claims use a format in which a claim cites two or more other claims (multiple claim format), but this is not limited to this. They may also be written using a format in which a multiple claim cites at least one other multiple claim (multi-multi claim).
[0081] The embodiments disclosed herein are illustrative in all respects and should not be considered as limiting. The scope of the present invention is defined by the claims, not by the above meaning, and is intended to include all modifications within the scope and meaning equivalent to the claims. [Explanation of symbols]
[0082] 10. Information processing device 11 Control section 12 Storage section 13. Communications Department 14 Input section 15 Display section M Natural Language Processing Model
Claims
1. Get detailed prompts that provide detailed specifications about the program code to be generated, The detailed prompt is input to a natural language processing model to obtain the program code. A program that causes a computer to carry out processing.
2. obtaining a summary prompt indicating a summary regarding said program code; The obtained summary prompt is input to a natural language processing model to obtain the detailed prompt. The program according to claim 1 , which causes the computer to execute a process.
3. Build processing for the acquired program code The program according to claim 1 or 2, which is executed by the computer.
4. A deployment process is performed on the executable file generated by the build process. The program according to claim 3, which is executed by the computer.
5. Summary Displays interactive information about the prompt, Obtaining the summary prompt as a response to the displayed dialogue information The program according to claim 2 , which causes the computer to execute a process.
6. The natural language processing model has a configuration for generating image data based on input data, Inputting the summary prompt into the natural language processing model to obtain the detailed prompt including image data. The program according to claim 2 , which causes the computer to execute a process.
7. When error information indicating the content of an error contained in the program code is generated by the build process, the program code and the generated error information are input into a natural language processing model to obtain a program code in which the error has been eliminated. The program according to claim 3, which causes the computer to execute a process.
8. The summary prompt includes at least one of text data, image data, audio data, a video file, a portable document format (pdf) file, and a binary file. The program according to claim 2.
9. The detailed prompt includes at least one of text data, image data, audio data, a video file, a pdf file, and a binary file.
3. The program according to claim 1 or 2.
10. The detailed prompt is output to a preview field. Accept edits to the detailed prompt displayed in the preview field; The edited detailed prompt is input to a natural language processing model to obtain the program code.
3. The program according to claim 1, which causes the computer to execute a process.
11. Output edit history information regarding edits accepted in response to the detail prompt The program according to claim 10, which causes the computer to execute a process.
12. When an instruction to return the detail prompt to a state before or after the execution of the editing process performed on the detail prompt is received based on the editing history information, the detail prompt and the program code are returned to the state before or after the execution of the editing process. The program according to claim 11, which causes the computer to execute a process.
13. The edited detail prompt and a program code corresponding to the unedited detail prompt are input to a natural language processing model, and the program code corresponding to the edited detail prompt is obtained. The program according to claim 10, which causes the computer to execute a process.
14. Extracting a difference between the detail prompt before editing and the detail prompt after editing; The extracted difference and the program code corresponding to the detailed prompt before the editing are input to a natural language processing model, and the program code corresponding to the detailed prompt after the editing is obtained. The program according to claim 10, which causes the computer to execute a process.
15. Outputting the program code in a preview field; The program code displayed in the preview field is edited.
3. The program according to claim 1, which causes the computer to execute a process.
16. Generate a detailed prompt corresponding to the edited program code based on the edited program code. The program according to claim 15, which causes the computer to execute a process.
17. outputting a screen having a GUI (Graphical User Interface) used for generating the program code; receiving setting information related to the program code via a GUI provided on the screen; The program code is generated based on the received setting information.
3. The program according to claim 1, which causes the computer to execute a process.
18. generating a detailed prompt corresponding to the program code based on the program code generated based on the setting information; The program according to claim 17, which causes the computer to execute a process.
19. An instruction to execute a process is received by the computer via an input field for receiving an input of the summary prompt. The program according to claim 2 , which causes the computer to execute a process.
20. Get detailed prompts that provide detailed specifications about the program code to be generated, The detailed prompt is input to a natural language processing model to obtain the program code. An information processing method in which processing is performed by a computer.
21. In an information processing device having a control unit, The control unit: Get detailed prompts that provide detailed specifications about the program code to be generated, The detailed prompt is input to a natural language processing model to obtain the program code. Information processing device.
Citation Information
Patent Citations
Software development program and software development method
JP6570436B2
Cited By
Drawing data generation device, drawing data generation method, and program
JP7919612B1
Llm-based automatic build error correction system and method
KR103033674B1
Program generation device and program generation method
WO2026186308A1
