Device and program

Abstract

A device according to one embodiment of the present disclosure generates software code, and comprises: a first generation unit that generates, in parallel on the basis of a description of code to be generated and a plurality of large language models, a plurality of elements included in the code to be generated ; and a second generation unit that, on the basis of the plurality of elements, generates the code to be generated.

Description

Device and Program

[0001] The present disclosure relates to a device and a program.

[0002] In recent years, many autoregressive large language models (LLMs) have been proposed (for example, Non-Patent Documents 1, 2, etc.), and coding automation technology has been proposed as a technology to support software development using these models.

[0003] OpenAI, GPT-4o System Card, arXiv 2024: https: / / arxiv.org / abs / 2410.21276Meta, The Llama 3 Herd of Models, arXiv 2024: https: / / arxiv.org / abs / 2407.21783

[0004] However, in conventional coding automation technology, depending on the length of the text constituting the code, it may take time until the output is obtained, and there is a problem that it is not always efficient.

[0005] The present disclosure has been made in view of the above points, and an object thereof is to provide a technology for supporting efficient software development.

[0006] A device according to an aspect of the present disclosure is a device that generates software code, and includes a first generation unit that generates a plurality of elements included in the code to be generated in parallel based on an explanation of the code to be generated and a plurality of large language models, and a second generation unit that generates the code to be generated based on the plurality of elements.

[0007] A technology for supporting efficient software development is provided.

[0008] This figure shows an example of creating a prompt from a prompt template and user input. This figure shows an example of the hardware configuration of the development support device according to the first embodiment. This figure shows an example of the functional configuration of the development support device according to the first embodiment. This flowchart shows an example of the development support process according to the first embodiment. This figure shows an example of the first prompt template. This figure shows an example of a meta template. This figure shows an example of the second prompt template. This figure shows an example of a template and parameters. This figure shows an example of code. This figure shows an example of the functional configuration of the development support device according to the second embodiment. This flowchart shows an example of the development support process according to the second embodiment. This figure shows an example of the third prompt template. This figure shows an example of modification parameters. This figure shows an example of modification code.

[0009] Hereinafter, the first and second embodiments of one embodiment of the present invention will be described in detail with reference to the drawings.

[0010] [Prior Art and its Problems] Autoregressive large-scale language models such as GPT (Non-Patent Literature 1) and Llama (Non-Patent Literature 2) are known. In addition, various coding automation technologies have been proposed to support software development using these large-scale language models (for example, References 1 and 2).Template-based coding (for example, Reference 3) is also known as a technology to improve coding efficiency.Template-based coding allows for the minimum amount of coding required by providing code templates, and enables intuitive coding by combining templates. The code may also be called, for example, "programming code" or "source code".

[0011] Many coding automation technologies utilize large-scale autoregressive language models to generate or modify software code. However, large-scale autoregressive language models process input text sequentially from beginning to end to generate output text (hereinafter referred to as "output text"). Therefore, if the output text is long, it takes a considerable amount of time to complete the output. Consequently, if the software code to be generated by the coding automation technology is long, there is a problem that it takes a considerable amount of time to output (hereinafter referred to as "Problem 1"). Furthermore, even when modifying software code, for example, it is necessary to re-output the output text from scratch, which also presents a problem that takes a considerable amount of time to complete if the output text is long (hereinafter referred to as "Problem 2").

[0012] Examples of cases where the output text is long when outputting the text that makes up the code include configuration files for HTML (HyperText Markup Language), CSS (Cascading Style Sheets), JS (JavaScript), and IaC (Infrastructure as Code) (e.g., Kubernetes configuration files).

[0013] Therefore, in the following first embodiment, a development support device 10 that solves the above problem 1 and supports efficient software development will be described. Furthermore, in the following second embodiment, a development support device 10 that solves the above problem 2 and supports efficient software development will be described. Note that the development support device 10 according to the first and second embodiments can be implemented by various information processing devices such as a PC (personal computer), a general-purpose server, a smartphone, or a tablet terminal. However, the development support device 10 according to the first and second embodiments may be implemented by a system composed of multiple information processing devices that are connected to each other in a manner that enables communication via any communication network, including the Internet.

[0014] [Prerequisite Knowledge] ・From this point forward, we will assume an autoregressive large-scale language model. Generally, a large-scale language model refers to a machine learning model that has been pre-trained on a large amount of text data using deep learning techniques, etc., in order to achieve a high level of language understanding.

[0015] In large-scale language models, a text-based prompt (also called an "instruction") is taken as input, and a response to that prompt is output in text format. In technologies that utilize large-scale language models, a prompt template (hereinafter also called a "prompt template") is generally prepared, and the given user input is embedded into the placeholders of the prompt template to create the prompt. This enables the dynamic creation of prompts in response to the given user input. The placeholder may also be called a "variable," for example.

[0016] For example, the prompt template 1010 shown in Figure 1 includes a placeholder 1011. When user input 1020 is provided, the user input 1020 is embedded in this placeholder 1011. This creates a prompt 1030 in the prompt template 1010 with the user input 1020 embedded in the placeholder 1011.

[0017] A template engine is a technology used in template-based coding that takes a meta-template, a template, and parameters as input and outputs documentation such as software code. A meta-template is data that defines the overall structure of the code output by the template engine. A template is data that defines a certain partial structure to be embedded in the meta-template. Parameters are data such as values ​​or characters that are embedded in the template.

[0018] There are various template engines available, but Jinja (Reference 4) is one of the well-known ones.

[0019] [First Embodiment] The development support device 10 according to the first embodiment will be described below.

[0020] <Example of Hardware Configuration of Development Support Device 10 According to the First Embodiment> Figure 2 is a diagram showing an example of the hardware configuration of the development support device 10 according to the first embodiment. As shown in Figure 2, the development support device 10 according to the first embodiment includes an input device 101, a display device 102, an external I / F 103, a communication I / F 104, a RAM (Random Access Memory) 105, a ROM (Read Only Memory) 106, an auxiliary storage device 107, and a processor 108. Each of these hardware components is connected to each other via a bus 109 so as to be able to communicate.

[0021] The input device 101 is, for example, a keyboard, mouse, touch panel, or physical button. The display device 102 is, for example, a display or display panel. Note that the development support device 10 does not necessarily have to have at least one of the input device 101 and the display device 102.

[0022] The external I / F 103 is an interface with external devices such as the recording medium 103a. Examples of recording media 103a include CDs (Compact Discs), DVDs (Digital Versatile Disks), SD memory cards (Secure Digital memory cards), and USB (Universal Serial Bus) memory cards.

[0023] The communication interface 104 is an interface for connecting to a communication network. The RAM 105 is a volatile semiconductor memory (storage device) that temporarily holds programs and data. The ROM 106 is a non-volatile semiconductor memory (storage device) that can retain programs and data even when the power is turned off. The auxiliary storage device 107 is a non-volatile storage device such as an HDD (Hard Disk Drive), SSD (Solid State Drive), or flash memory. The processor 108 is an arithmetic unit such as a CPU (Central Processing Unit).

[0024] Note that the hardware configuration shown in Figure 2 is just one example, and the hardware configuration of the development support device 10 is not limited to this. For example, the development support device 10 may have multiple auxiliary storage devices 107 and multiple processors 108, it may not have some of the hardware shown, or it may have various hardware other than the hardware shown.

[0025] <Example of Functional Configuration of Development Support Device 10 According to the First Embodiment> Figure 3 is a diagram showing an example of the functional configuration of the development support device 10 according to the first embodiment. As shown in Figure 3, the development support device 10 according to the first embodiment includes an input unit 111, a first prompt creation unit 112, a first code element generation unit 113, a second prompt creation unit 114, a second code element generation unit 115, a template engine unit 116, and an output unit 117. Each of these units is realized, for example, by a process in which one or more programs installed in the development support device 10 are executed by a processor 108 or the like.

[0026] The input unit 111 receives the code description 2010 as input data. The code description 2010 is text that expresses, in natural language or the like, a description of the code that the user wants to generate (e.g., a description of the software functions that the code wants to realize). In addition to text, the code description 2010 may also include content such as images that represent the description of the code that the user wants to generate.

[0027] The first prompt creation unit 112 creates the first prompt 4010 using the code description 2010 and the first prompt template 3010. The first prompt template 3010 is a prompt template that instructs the large-scale language model to generate a meta-template that will be input to the template engine. The first prompt 4010 is a prompt that instructs the large-scale language model to generate a meta-template that will be input to the template engine. The first prompt 4010 is created by embedding the code description 2010 into the placeholders included in the first prompt template 3010.

[0028] The first code element generation unit 113 creates a meta-template 6010 using the first prompt 4010 and the large-scale language model 5010. That is, the first code element generation unit 113 inputs the first prompt 4010 to the large-scale language model 5010, and the large-scale language model 5010 generates the meta-template 6010 as a response to the first prompt 4010. The meta-template 6010 is data that defines the structure of the entire code that the user desires to be generated, and can therefore be said to be an element of that code.

[0029] The large-scale language model 5010 may be owned by the development support device 10, or it may be owned by a server (e.g., an external server such as a cloud server) that is connected to the development support device 10 in a communicative manner.

[0030] The second prompt creation unit 114 creates the second prompt 4020 using the code description 2010, the meta template 6010, and the second prompt template 3020. The second prompt template 3020 is a prompt template that instructs the large-scale language model to generate a template that will be input to the template engine. The second prompt 4020 is a prompt that instructs the large-scale language model to generate a template that will be input to the template engine.

[0031] The second code element generation unit 115 generates one or more templates 6020 and one or more corresponding parameters 6030 using the second prompt 4020 and one or more large-scale language models 5020. That is, the second code element generation unit 115 duplicates the second prompt 4020 as many times as there are templates to be embedded in the meta-template 6010, and then inputs each of the second prompts 4020 in parallel to each of the large-scale language models 5020, thereby generating a template 6020 and parameters 6030 in each of the large-scale language models 5020 as a response to each of the second prompts 4020. Since the templates 6020 and parameters 6030 are data embedded in the meta-template 6010, they can be said to be elements of code that the user desires to be generated.

[0032] Hereinafter, let N be the number of templates embedded in the metatemplate 6010, and the nth (where n = 1, ..., N)th template 6020 and parameter 6030 will also be referred to as "template 6020-n" and "parameter 6030-n," respectively. Furthermore, the large-scale language model 5020 that generates template 6020-n and parameter 6030-n will also be referred to as "large-scale language model 5020-n."

[0033] Each of the one or more large-scale language models 5020 may be owned by the development support device 10, or it may be owned by a server (e.g., an external server such as a cloud server) that is connected to the development support device 10 in a communicative manner. Also, one of the one or more large-scale language models 5020 may be a large-scale language model 5010.

[0034] The template engine unit 116 generates code 2020 using the meta-template 6010, N templates 6020, and N parameters 6030. That is, for n=1, ..., N, the template engine unit 116 generates code 2020 by embedding parameters 6030-n into placeholders included in template 6020-n, and embedding template 6020-n into placeholders included in meta-template 6010. This is also called rendering. This generates code 2020 for the software desired by the user. The template engine unit 116 is implemented, for example, by a program that implements a template engine (e.g., Jinja).

[0035] The output unit 117 outputs code 2020 as output data to a predetermined output destination. This output destination is not limited to a specific destination, but examples include a display device 102 such as a display, the storage area of ​​the auxiliary storage device 107, a device connected to the development support device 10 in a communicative manner (e.g., a repository), a predetermined program (e.g., a compiler), etc.

[0036] <Example of development support processing according to the first embodiment> Figure 4 is a flowchart of an example of development support processing according to the first embodiment. Hereinafter, it is assumed that the development support device 10 is provided with code description 2010 as input data.

[0037] The input unit 111 inputs the code description 2010 given as input data (step S101).

[0038] The first prompt creation unit 112 creates the first prompt 4010 using the code description 2010 and the first prompt template 3010 (step S102).

[0039] Here, an example of the first prompt template 3010 is shown in Figure 5. The first prompt template 3010 shown in Figure 5 consists of a system prompt section 3011 where instructions such as the role of the large-scale language model are set, and a user prompt section 3012 where user input and specific instructions are set. The user prompt section 3012 also includes a placeholder 3013. The first prompt 4010 is created by embedding a code description 2010 into this placeholder 3013.

[0040] Furthermore, the system prompt section 3011 is configured with a format instruction from LangChain (Reference 5) to output the output text of the large-scale language model (i.e., the meta-template 6010) in JSON format. This facilitates data management when managing the output text of the large-scale language model 5010. The JSON format data can be easily retrieved using a JSON parser.

[0041] However, LangChain is just one example, and other libraries can also be used. This principle applies to subsequent examples as well.

[0042] The first code element generation unit 113 creates a meta template 6010 using the first prompt 4010 and the large-scale language model 5010 (step S103). That is, the first code element generation unit 113 inputs the first prompt 4010 to the large-scale language model 5010, and the large-scale language model 5010 generates the meta template 6010 as a response to the first prompt 4010.

[0043] Here, an example of the meta template 6010 is shown in Figure 6. The meta template 6010 shown in Figure 6 is a meta template for HTML code. The meta template 6010 shown in Figure 6 includes placeholders 6011 and 6012 into which the template is embedded. Therefore, in this case, N = 2.

[0044] The second prompt creation unit 114 creates the second prompt 4020 using the code description text 2010, the meta-template 6010, and the second prompt template 3020 (step S104).

[0045] Here, an example of the second prompt template 3020 is shown in FIG. 7. The second prompt template 3020 shown in FIG. 7 includes a system prompt part 3021 where instructions such as the role of the large language model are set, and a user prompt part 3022 where user input, specific instructions, etc. are set. Further, the system prompt part 3021 includes a placeholder 3023, and the user prompt part 3022 includes placeholders 3024 and 3025. By embedding the file names of the template 6020 and the parameter 6030 in the placeholder 3023, the code description text 2010 in the placeholder 3024, and the meta-template 6010 in the placeholder 3025, the second prompt 4020 is created.

[0046] Also, in the system prompt part 3021, similar to the system prompt part 3011 of the first prompt template 3010 shown in FIG. 5, an instruction to output the output text of the large language model (that is, the template 6020 and the parameter 6030) in JSON format is set by the format instruction text of LangChain. This facilitates data management when managing the output text of the large language model 5020.

[0047] The second code element generation unit 115 generates one or more templates 6020 and one or more parameters 6030 corresponding thereto using the second prompt 4020 and one or more large language models 5020 (step S105). That is, the second code element generation unit 115 generates one or more templates 602 and one or more parameters 6030 corresponding thereto, for example, according to the following procedures 1-1 to 1-2.

[0048] Step 1-1: The second code element generation unit 115 duplicates the second prompt 4020 to create N second prompts 4020. Hereinafter, the n-th (where n = 1,..., N) second prompt 4020 is also represented as "second prompt 4020-n". Also, it is assumed that the second prompt 4020-n is input to the large language model 5020-n.

[0049] Note that for n = 1,..., N, each second prompt 4020-n is not completely identical, and a part (e.g., the file name embedded in the placeholder 3023) is different according to the large language model 5020 to which the second prompt 4020-n is input, but it may also be completely identical. As an example, when making the file names embedded in the placeholder 3023 different, the second code element generation unit 115 may assign a serial number to the file name when duplicating the second prompt 4020.

[0050] Step 1-2: The second code element generation unit 115 inputs the second prompt 4020-n to the large language model 5020-n in parallel for n = 1,..., N, thereby generating a template 6020-n and a parameter 6030-n as answers to the second prompt 4020-n. As a result, even if the text constituting the entire code to be generated is temporarily long, it is possible to generate partial codes (in other words, elements of the code to be generated) in units of the template 6020 and the parameter 6030 in parallel, so efficient code generation is possible.

[0051] Note that in the above step 1-2, the large language model 5020-n generates the template 6020-n and the parameter 6030-n. However, for example, the large language model 5020-n may generate the template 6020-n in which the parameter 6030-n is embedded. <9999999>

[0052] Here, an example of template 6020 and parameter 6030 for the case N=2 is shown in Figure 8. The template 6020 and parameter 6030 shown in Figure 8 are HTML code templates and parameters. Template 6020-1 shown in Figure 8 contains placeholder 6021-1, into which parameter 6030-1 is embedded. Similarly, template 6020-2 shown in Figure 8 contains placeholder 6021-2, into which parameter 6030-2 is embedded.

[0053] The template engine unit 116 generates code 2020 using the meta template 6010, N templates 6020, and N parameters 6030 (step S106). That is, the template engine unit 116 generates code 2020 by rendering the meta template 6010, N templates 6020, and N parameters 6030.

[0054] Here, an example of code 2020 is shown in Figure 9. Code 2020 shown in Figure 9 is HTML code generated by rendering the meta template 6010 shown in Figure 6, templates 6020-1 and 6020-2 shown in Figure 8, and parameters 6030-1 and 6030-2 shown in Figure 8.

[0055] The output unit 117 outputs code 2020 as output data to a predetermined output destination (step S107).

[0056] [Second Embodiment] The development support device 10 according to the second embodiment will be described below.

[0057] <Example of hardware configuration of the development support device 10 according to the second embodiment> The hardware configuration of the development support device 10 according to the second embodiment may be the same as that of the first embodiment, so its description is omitted.

[0058] <Example of Functional Configuration of Development Support Device 10 According to the Second Embodiment> Figure 10 is a diagram showing an example of the functional configuration of the development support device 10 according to the second embodiment. As shown in Figure 10, the development support device 10 according to the second embodiment includes an input unit 121, a third prompt creation unit 122, a correction code element generation unit 123, a template engine unit 124, and an output unit 125. Each of these units is realized, for example, by a process in which one or more programs installed in the development support device 10 are executed by a processor 108 or the like.

[0059] The input unit 121 inputs the correction instruction statement 2030 provided as input data. The correction instruction statement 2030 is text that expresses, in natural language or the like, the correction instructions for the code that the user wishes to correct (hereinafter also referred to as the "code to be corrected"). The correction instructions do not necessarily have to explicitly indicate the part of the code to be corrected; for example, they may be error messages or the like, which do not explicitly indicate the part to be corrected. In addition to text, the correction instruction statement 2030 may also include content such as images that represent the correction instructions for the code to be corrected (e.g., a hard copy of an error screen). Furthermore, if the code to be corrected is also provided as input data, the input unit 121 inputs the code to be corrected in addition to the correction instruction statement 2030.

[0060] The third prompt creation unit 122 creates the third prompt 4030 using the modification instruction statement 2030, the third prompt template 3030, the meta template 6010 used when generating the code to be modified, one or more templates 6020, and one or more corresponding parameters 6030. The third prompt template 3030 is a prompt template that instructs the large-scale language model to generate data with at least one of the meta template 6010, template 6020, and parameter 6030 modified. The third prompt 4030 is a prompt that instructs the large-scale language model to generate data with at least one of the meta template 6010, template 6020, and parameter 6030 modified.

[0061] Hereafter, the data obtained by modifying metatemplate 6010 will also be referred to as "modified metatemplate 6010". Furthermore, if N is the number of templates embedded in metatemplate 6010, then for n = 1, ..., N, the data obtained by modifying template 6020-n will also be referred to as "modified template 6020-n". Similarly, the data obtained by modifying parameter 6030-n will also be referred to as "modified parameter 6030-n".

[0062] The modified code element generation unit 123 modifies at least one of the meta-template 6010, template 6020, and parameter 6030 using the third prompt 4030 and the large-scale language model 5030. That is, the modified code element generation unit 123 inputs the third prompt 4030 to the large-scale language model 5030, and the large-scale language model 5030 generates at least one of the modified meta-template 6010, modified template 6020-n, and modified parameter 6030-n as a response to the third prompt 4030. Subsequently, the modified code element generation unit 123 modifies at least one of the meta-template 6010, template 6020, and parameter 6030 by overwriting the pre-modification data with these modified data. At this time, the modified code element generation unit 123 may save the pre-modification data as history in the storage area of ​​the auxiliary storage device 107.

[0063] The large-scale language model 5030 may be owned by the development support device 10, or it may be owned by a server (e.g., an external server such as a cloud server) that is connected to the development support device 10 in a communicative manner.

[0064] The template engine unit 124 generates a modified code 2040, which is the modified code of the code to be modified, using the meta-template 6010, N templates 6020, and N parameters 6030. That is, for n=1, ..., N, the template engine unit 124 generates the modified code 2040 by embedding the parameters 6030-n into the placeholders included in template 6020-n, and embedding template 6020-n into the placeholders included in meta-template 6010. This provides a modified code 2040 in which the code to be modified has been modified as desired by the user. The template engine unit 124 is implemented, for example, by a program that implements a template engine (e.g., Jinja).

[0065] The output unit 125 outputs the correction code 2040 as output data to a predetermined output destination. This output destination is not limited to a specific destination, but examples include a display device 102 such as a display, the storage area of ​​the auxiliary storage device 107, a device connected to the development support device 10 in a communicative manner (e.g., a repository), a predetermined program (e.g., a compiler), etc.

[0066] <Example of development support processing according to the second embodiment> Figure 11 is a flowchart showing an example of development support processing according to the second embodiment. Hereinafter, it is assumed that the development support device 10 is provided with a modification instruction statement 2030 as input data.

[0067] The input unit 121 receives the correction instruction statement 2030 as input data (step S201).

[0068] The third prompt creation unit 122 creates the third prompt 4030 using the correction instruction statement 2030, the third prompt template 3030, the meta template 6010 used when generating the code to be corrected, one or more templates 6020, and one or more parameters 6030 corresponding to them (step S202).

[0069] Here, an example of the third prompt template 3030 is shown in Figure 12. The third prompt template 3030 shown in Figure 12 consists of a system prompt section 3031 where instructions such as the role of the large-scale language model are set, and a user prompt section 3032 where user input and specific instructions are set. The user prompt section 3032 also includes placeholders 3033 to 3036. The third prompt 4030 is created by embedding the meta template 6010 into placeholder 3033, the template 6020 and parameter 6030 into placeholder 3034, the code to be modified into placeholder 3035, and the modification instruction statement 2030 into placeholder 3036. The code to be modified embedded into placeholder 3035 may be generated by the template engine from the meta template 6010, template 6020 and parameter 6030, or it may be input by the input unit 121 if the code to be modified is provided as input data.

[0070] Furthermore, the system prompt section 3031 is configured with a LangChain format instruction to output the output text of the large-scale language model in JSON format. This facilitates data management when managing the output text of the large-scale language model 5030.

[0071] The modified code element generation unit 123 modifies at least one of the meta-template 6010, template 6020, and parameter 6030 using the third prompt 4030 and the large-scale language model 5030 (step S203). That is, the modified code element generation unit 123 modifies at least one of the meta-template 6010, template 6020, and parameter 6030 by, for example, the following procedures 2-1 to 2-2.

[0072] Procedure 2-1: The correction code element generation unit 123 inputs the third prompt 4030 to the large language model 5030, thereby generating at least one of the correction meta template 6010, correction template 6020-n, and correction parameter 6030-n in the large language model 5030 as a response to the third prompt 4030.

[0073] For simplicity, in the following procedure 2-1, we will assume that the modified parameter 6030-2 shown in Figure 13 has been generated. The modified parameter 6030-2 shown in Figure 13 is data in which parameter 6030-2 has been modified by the large-scale language model 5030.

[0074] Step 2-2: The modified code element generation unit 123 overwrites at least one of the meta template 6010, template 6020, and parameter 6030 with data generated by the large-scale language model 5030. That is, the modified code element generation unit 123 modifies parameter 6030-2 by overwriting parameter 6030-2 with modified parameter 6030-2, for example. This enables efficient code modification because, even if the text constituting the entire code to be modified is long, only the partial code that needs to be modified (in other words, the elements in the code to be modified that need to be modified) needs to be modified and generated.

[0075] The template engine unit 124 generates the modification code 2040 using the meta template 6010, N templates 6020, and N parameters 6030 (step S204). That is, the template engine unit 124 generates the modification code 2040 by rendering the meta template 6010, N templates 6020, and N parameters 6030.

[0076] Here, the code 2020 shown in Figure 9 is the code to be modified, and an example of the modified code 2040 when the modified parameter 6030-2 shown in Figure 13 is generated in the above procedure 2-1 is shown in Figure 14. The modified code 2040 shown in Figure 14 is HTML code generated by rendering the meta template 6010 shown in Figure 6, templates 6020-1 and 6020-2 shown in Figure 8, parameter 6030-1 shown in Figure 8, and parameter 6040-2 which is obtained by modifying parameter 6030-2 shown in Figure 8 with the modified parameter 6030-2 shown in Figure 13.

[0077] The output unit 125 outputs the correction code 2040 as output data to a predetermined output destination (step S205).

[0078] [Summary] As described above, the development support device 10 according to the first embodiment performs template-based coding on a large-scale language model and generates multiple templates and parameters in parallel using multiple large-scale language models. This makes it possible to efficiently generate the code for the software desired by the user, thereby supporting efficient software development.

[0079] Furthermore, in the development support device 10 according to the second embodiment, when modifying a code based on template-based coding, the large-scale language model is used to determine the templates and parameters that need modification, and only the templates and parameters that need modification are generated by the large-scale language model. This makes it possible to efficiently modify the code desired by the user, thereby supporting efficient software development.

[0080] Furthermore, the first and second embodiments described above can be combined. That is, the development support device 10 may perform both the development support processing according to the first embodiment and the development support processing according to the second embodiment.

[0081] The present invention is not limited to the embodiments specifically disclosed above, and various modifications, changes, and combinations with known technologies are possible without departing from the spirit of the claims.

[0082] [References] Reference 1: M. Chen et al., Evaluating Large Language Models Trained on Code, arXiv 2021: https: / / arxiv.org / abs / 2107.03374 Reference 2: X. Chen et al., Teaching Large Language Models to Self-Debug, ICLR 2024: https: / / openreview.net / forum?id=KuPixIqPiq Reference 3: E. Syriani et al., Systematic mapping study of template-based code generation, Computer Languages, Systems & Structures 2018: https: / / www.sciencedirect.com / science / article / abs / pii / S1477842417301239 Reference 4: Jinja (GitHub repository): https: / / github.com / pallets / jinja Reference 5: LangChain (GitHub repository): https: / / github.com / langchain-ai / langchain

[0083] 10 Development support device 101 Input device 102 Display device 103 External I / F 103a Recording medium 104 Communication I / F 105 RAM 106 ROM 107 Auxiliary storage device 108 Processor 109 Bus 111 Input unit 112 First prompt creation unit 113 First code element generation unit 114 Second prompt creation unit 115 Second code element generation unit 116 Template engine unit 117 Output unit 121 Input unit 122 Third prompt creation unit 123 Modified code element generation unit 124 Template engine unit 125 Output unit

Claims

1. A device for generating software code, comprising: a first generation unit that generates a plurality of elements included in the code to be generated in parallel based on a description of the code to be generated and a plurality of large-scale language models; and a second generation unit that generates the code to be generated based on the plurality of elements.

2. A program for generating software code, which causes a computer to execute: a first generation procedure that generates a plurality of elements included in the code to be generated in parallel based on a description of the code to be generated and a plurality of large-scale language models; and a second generation procedure that generates the code to be generated based on the plurality of elements.

3. A device for modifying software code, comprising: a modification unit that modifies elements that need to be modified from among a plurality of elements included in the code to be modified, based on modification instructions for the code to be modified and a large-scale language model; and a generation unit that generates modified code from the code to be modified, based on the plurality of elements including the modified elements.

4. A program for modifying software code, which causes a computer to execute: a modification procedure for modifying elements that need to be modified from among a plurality of elements included in the code to be modified, based on modification instructions for the code to be modified and a large-scale language model; and a generation procedure for generating code that modifies the code to be modified based on the plurality of elements including the modified elements.

Images