Computer program, information processing device, and information processing method

Abstract

This invention provides computer programs, information processing devices, and information processing methods that support software development. [Solution] The computer program causes the computer to analyze document data relating to the functional design of each of the multiple implemented source codes stored in storage, and for each function realized by each of the multiple implemented source codes, create reference data that includes text indicating the purpose or outline of the function identified based on the analysis of the document data, and an association with other implemented source codes that realize similar functions, analyze data relating to the functional design of the new source code, identify the function identified by the analysis results and implemented source codes that realize similar functions from the storage using the reference data, and output the identified implemented source codes along with the similarities of the functions.

Description

Technical Field

[0001] The present invention relates to a computer program, an information processing apparatus, and an information processing method for supporting software development.

Background Art

[0002] Software development using generative AI (Artificial Intelligence) such as large language models is in progress. This is because by using a language model, it becomes possible to search for appropriate source code from an enormous number of disclosed source codes that cannot be completely searched by humans. Patent Document 1 discloses the use of a large language model in software development.

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] By using generative AI, it is possible to automatically generate source code described plausibly or automatically generate test scenarios and test items. However, there is a possibility that source code that cannot withstand operation may be output from the generative AI model. Therefore, source code generated from scratch using generative AI requires checking for grammatical errors or checking whether it conforms to requirements or designs, and the efficiency improvement by using generative AI may rather increase the man-hours.

[0005] An object of the present invention is to provide a computer program, an information processing apparatus, and an information processing method for supporting software development.

Means for Solving the Problems

[0006] A computer program in one embodiment of the present disclosure causes the computer to analyze document data relating to the functional design of each of a plurality of implemented source codes stored in storage, create reference data for each function realized by each of the plurality of implemented source codes, which includes text indicating the purpose or outline of the function identified based on the analysis of the document data, and an association with other implemented source codes that realize a similar function, analyze data relating to the functional design of a new source code, identify an implemented source code that realizes a function similar to the function identified by the analysis results from the storage using the reference data, and output the identified implemented source code along with the similarities of the functions.

[0007] The computer program, information processing device, and information processing method disclosed herein use a language model, but instead of having the language model generate source code, it extracts and presents source code that has already undergone testing, etc., using the language model. In this disclosure, instead of searching for words contained in the source code, source code with similar purpose, specifications, structure, etc., to the source code under development is extracted using the results of source code analysis.

[0008] In this disclosure, source code is not limited to the code of a software program written to perform a specific function on a computer, but also includes test code that causes the computer to run tests to verify whether the software program is functioning as designed. In addition to source code and test code, test scenarios, test items, etc., may also be included. [Effects of the Invention]

[0009] According to this disclosure, software development support using language models can be realized. [Brief explanation of the drawing]

[0010] [Figure 1]This is an overview diagram of the development support system. [Figure 2] This is a block diagram showing the configuration of an information processing device. [Figure 3] This is an explanatory diagram of a language model module used in an information processing device. [Figure 4] This is a block diagram showing the configuration of a terminal device. [Figure 5] This flowchart shows an example of the procedure for creating reference data using an information processing device. [Figure 6] This is an explanatory diagram showing an example of the content of the reference data. [Figure 7] This flowchart shows an example of a procedure for processing and presenting useful information using an information processing device. [Figure 8] This figure shows an example of a search screen based on a terminal program. [Figure 9] This figure shows an example of a search screen based on a terminal program. [Figure 10] This flowchart shows an example of the information presentation processing procedure by the information processing device of the second embodiment. [Figure 11] This figure shows an example of a search screen based on the terminal program of the second embodiment. [Figure 12] This figure shows an example of a search screen based on the terminal program of the second embodiment. [Modes for carrying out the invention]

[0011] This disclosure will be described in detail with reference to drawings illustrating its embodiments. The following embodiments describe a development support system using the computer program of this disclosure.

[0012] [First Embodiment] Figure 1 is an overview diagram of the development support system 100. The development support system 100 disclosed herein presents useful document data to users who are software program design and development engineers, based on document data recorded as achievements by the user themselves and the software program design and development company to which the user belongs.

[0013] The development support system 100 includes an information processing device 1 and a terminal device 2. The information processing device 1 is connected to a local network LN within the business of a software program design and development company, and is communicatively connected from the terminal device 2 used by a user. The information processing device 1 may be a cloud server, or may be configured to be accessible only from the terminal device 2 permitted via the local network LN. The local network LN is a network laid within the design and development company, but may include a VPN (Virtual Private Network) via a network N that is a public communication network. The local network LN may be either wireless or wired.

[0014] A storage 300 that stores source code and software development-related documents created by the design and development company as resources is communicatively connected to the local network LN of the design and development company. The terminal device 2 of a user who is a member of the design and development company and the information processing device 1 can read data from the storage 300 via the local network LN.

[0015] A user who is a design / development engineer belonging to a software program design and development company creates software development-related documents such as a "development specification document", a "design document", and a "requirements definition document" for a system or the like to be designed and developed. The user creates source code to realize a system that can exhibit the functions shown in those software development-related documents. Also, regarding testing of the system, a user who is a testware engineer creates a "test design document", a "test item definition", etc., and creates test code. In the following description, these test-related development documents are included in the "software development-related documents", and the test code is also included in the "source code".

[0016] Storage 300 stores document data including source code created by a user and software development-related documents, associating it with a project ID. In Storage 300, the source code and software development-related documents are not only created but also updated by the intervention operations of multiple users in correspondence with the cyclic repetition of the processes of debugging, testing, and deployment, based on a quality improvement method called Continuous Integration. Storage 300 may store document data related to contracts such as estimates, invoices, and purchase orders created for a project, associating it with the project ID.

[0017] When creating source code, the user hopes to make the work as efficient as possible. Here, it can be assumed that the user uses the so-called generative AI that is frequently used these days, specifically Chat-GPT (registered trademark), etc., and gives the requirements for the system described in the design document, etc. to the generative AI to output the source code, thereby achieving efficiency. However, in this case, it is necessary to perform checks such as grammar errors in the output source code or checks to see if it conforms to the requirements or design until it can withstand operation, and it requires engineers with advanced knowledge of test implementation and their man-hours.

[0018] Therefore, in the development support system 100 of the present disclosure, the information processing device 1 executes a process of reading out and presenting document data such as source code that may include descriptions, definitions, or structures necessary to exert the functions, by specifying the outline and purpose of the required functions for the system to be created and developed by a design and development business operator, from the storage 300.

[0019] Details of each device and process for realizing the development support system 100 capable of presenting such document data will be described below.

[0020] Figure 2 is a block diagram showing the configuration of the information processing device 1. The information processing device 1 is a server computer. The server computer is described as an on-premise server accessible within the local network LN and managed by the design and development company, but it may also be a cloud server managed by a system development support company. The information processing device 1 may also be a desktop or laptop personal computer.

[0021] The information processing device 1 comprises a processing unit 10, a storage unit 11, and a communication unit 12. The processing unit 10 is a processor such as one or more CPUs (Central Processing Units), MPUs (Micro-Processing Units), GPUs (Graphics Processing Units), or NPUs (Neural Processing Units). The processing unit 10 includes memory such as SRAM (Static Random Access Memory) or DRAM (Dynamic Random Access Memory). The processing unit 10 reads the information processing program P1 stored in the storage unit 11 into memory and executes it, thereby causing a general-purpose computer to perform various processes described later.

[0022] The storage unit 11 is a relatively large-capacity non-volatile storage medium such as an SSD (Solid State Drive) or a Hard Disk Drive. The storage unit 11 stores the program (program product) necessary for the processing unit 10 to execute processing, and reference configuration data. The program product includes an information processing program P1 and a language model module M1.

[0023] The information processing program P1 and language model module M1 stored in the memory unit 11 may be obtained by the processing unit 10 reading the information processing program P9 and language model module M9 stored in a non-temporary storage medium 9 that can be read from a computer and storing them in the memory unit 11. Alternatively, the information processing program P1 and language model module M1 may be obtained by the processing unit 10 downloading them from an external download server via the communication unit 12 and storing them in the memory unit 11.

[0024] The memory unit 11 stores and updates the reference data R1 created by the processing unit 10 based on the information processing program P1. The reference data R1 will be described later.

[0025] The communication unit 12 enables communication with the terminal device 2 via the local network LN. The communication unit 12 is, for example, a network card. The communication unit 12 may also be a wireless communication device that enables communication via a wireless communication medium such as a wireless LAN. The processing unit 10 can access the storage 300 via the local network LN through the communication unit 12.

[0026] Figure 3 is an explanatory diagram of the language model module M1 used in the information processing device 1. The language model module M1 includes a model known as the language model LM. The language model module M1 may also include a large-scale language model (LLM: Large LM) such as GPT-4. Some components of the language model module M1, such as the language model LM, may be running on an external server (GPT-4, Gemini, Claude, etc.), and the processing unit 10 may use them via the communication unit 12. The language model LM is a model trained using a neural network to output natural language data (natural sentences) using words with high occurrence probabilities from a set of words input as vector data. Various methods, including Transformer, can be employed as algorithms for the language model LM.

[0027] The language model module M1 receives prompts (data such as text entered in response to prompts in the user interface) that correspond to requests to the language model LM. Depending on the instruction contained in the prompt, the language model module M1 outputs analysis results or response sentences using software development-related documents or reference data R1 created by the process described later.

[0028] The language model module M1 analyzes pre-created software development-related documents for already created and verified source code, in accordance with the instructions contained in the received prompt. The language model module M1 uses the software development-related documents to output the analysis results regarding the functionality of the source code described in the software development-related documents to the language model LM. The language model module M1 also associates the analysis results with the language model LM based on their similarity, and creates and stores reference data R1 that summarizes the analysis results and the association results.

[0029] Language model module M1 performs the function of extracting appropriate document data for source code and outputting a response sentence in response to a prompt containing data indicating a request for new source code to be created. Using the received prompt and the pre-created reference data R1, language model module M1 performs a search on the source code stored in storage 300 and causes language model LM to create a response sentence. In response to a user request, language model module M1 instructs language model LM to extract appropriate document data from the document data stored in storage 300 and output a response sentence, and retrieves the response sentence from language model LM.

[0030] The language model module M1 may, if the source code to be analyzed relates to ERP (Enterprise Resource Planning) or a core system, use terminology definitions and scale information for each of the multiple business processes in the system as knowledge. This allows the language model module M1 to output a response to a given prompt that would be presented by a skilled software designer for ERP. Regardless of whether it relates to ERP, the language model module M1 may also use terminology definition information according to the technical field, business field, etc. to which the source code to be analyzed applies as knowledge data.

[0031] Figure 4 is a block diagram showing the configuration of terminal device 2. Terminal device 2 is a laptop or desktop personal computer used by a user who is an engineer at a design and development company. Terminal device 2 may also be a smartphone or tablet device.

[0032] The terminal device 2 comprises a processing unit 20, a storage unit 21, a communication unit 22, a display unit 23, and an operation unit 24.

[0033] The processing unit 20 is one or more processors such as CPUs, MPUs, GPUs, or NPUs. The processing unit 20 includes memory such as SRAM or DRAM. The processing unit 20 controls each component to execute processing. The processing unit 20 may be configured as a single hardware system (SoC) integrating the processor, memory, and the communication unit 22 described later. Based on the program stored in the storage unit 21, the processing unit 20 sends and receives data to and from the information processing device 1 and accepts user operations. Details will be described later.

[0034] The storage unit 21 uses non-volatile memory such as a hard disk, flash memory, or SSD. The storage unit 21 stores programs and data referenced by the processing unit 20. The storage unit 21 stores the terminal program (program product) P2. The terminal program P2 is a web browser program, and may also be a web application program provided by the information processing device 1. The terminal program P2 stored in the storage unit 21 may be one that the processing unit 20 reads, copies, and installs from the terminal program P8 stored in the storage medium 8. The terminal program P2 may also be one that the terminal device 2 downloads from a program server (not shown), stores in the storage unit 21, and installs.

[0035] The communication unit 22 is a communication device that enables communication via the local network LN. The communication unit 22 is, for example, a network card that corresponds to the local network LN. The communication unit 22 may also be a communication device that enables wireless communication. The processing unit 20 can send and receive data between the information processing device 1 and the storage 300 via the communication unit 22.

[0036] The display unit 23 is a display such as a liquid crystal display or an organic EL (Electro-Luminescence) display. The display unit 23 may also be a touch panel-integrated display. Information output may be provided by an audio output unit including a speaker.

[0037] The operation unit 24 is a user interface that enables input and output to and from the processing unit 20. The operation unit 24 may be a touch panel built into the display unit 23, or it may be configured to include physical buttons, switches, and physical dials. The operation unit 24 may also be an audio input / output unit including a microphone and a speaker.

[0038] The processing in the development support system 100 configured in this way will be explained with reference to a flowchart. As a preliminary step, the information processing device 1 first creates reference data R1 for the document data stored in the storage 300. Figure 5 is a flowchart showing an example of the procedure for creating reference data R1 by the information processing device 1.

[0039] The processing unit 10 of the information processing device 1 selects the case ID of the case (step S101) and reads the software development-related documents associated with the selected case ID from the storage 300 (step S102). The processing unit 10 obtains the file path in the storage 300 of the source code or other software development-related documents corresponding to the selected case ID (step S103).

[0040] The processing unit 10 converts the software development-related documents read in step S102 into text data (step S104). In step S104, the processing unit 10 converts the software development-related documents into text data one by one, for example. In step S104, the processing unit 10 may also convert each function described in the software development-related documents into text data one by one.

[0041] In step S104, the processing unit 10 converts the content of the software development-related documents into text data so that the language model LM can easily understand it. For example, the processing unit 10 describes the software development-related documents in JSON format, separating chapters, sections, paragraphs, etc., using specific symbols (e.g., curly braces {}) to indicate meaning. The software development-related documents may use diagrams and tables to make the structure of the software easier to understand visually. In particular, if the software includes a GUI, it may include images of the GUI screen. The software development-related documents may be designed to facilitate intuitive understanding, such as by using color-coded tables. When the information processing device 1 converts to text data in step S104, it also performs image recognition processing on software development-related documents that include images to convert them into text. For example, the processing unit 10 extracts text data such as "data input" and "item" included in the UI from the GUI image data. In step S104, the processing unit 10 may extract text contained in the image using image recognition technology or OCR, or it may convert the image into text data using a neural network and a trained model (separate from the language model module M1) that has been trained to output an overview of the GUI screen as text when GUI screen image data is input. The processing unit 10 may also use an existing image recognition model using technologies such as Vision Transformer and LayoutLM to recognize text contained in image data of diagrams and tables included in the content of software development-related documents, along with the position of the text within the image data (for example, which line it is on).

[0042] The processing unit 10 uses the converted text data to create a prompt containing an instruction that tells the language model module M1 to output the results of analyzing the requirements for the source code created for the case identified by the case ID (step S105). In step S105, the processing unit 10 creates a prompt in natural language containing an instruction that asks, for example, to list the overview and purpose by function as described in the software development-related documents. The processing unit 10 may also add a role to the prompt as the language model LM, such as being an expert in software design and development in the field of the case identified by the case ID. The processing unit 10 is not limited to creating a prompt containing an instruction that asks to list by function as described in the software development-related documents; instead, it may create a prompt containing an instruction that asks to identify the overview and purpose of the corresponding function, or the requirements for the function, from the converted text data, for each function described in the source code obtained in step S103.

[0043] The processing unit 10 provides the text data of the software development-related documents obtained in step S104 and the text data of the prompts created in step S105 to the language model module M1 (step S106). In step S106, the processing unit 10 uses the language model module M1 to convert the text data of the prompts and software development-related documents, which are written in natural language, into vector data, and provides the combined input data to the language model LM. In step S106, the processing unit 10 may also provide the language model LM with vector data of knowledge about the software development-related documents, which has been converted into vector data, as knowledge, along with the input data.

[0044] The processing unit 10 stores the analysis results of the requirements for the created source code, output from the language model module M1, in the storage unit 11 as reference data R1 (step S107). In step S107, the processing unit 10 stores data listing the overview and purpose of each function, for example, as described in software development-related documents. In step S107, the processing unit 10 may also store a list of the overview and purpose of each function, or the requirements, as described in the source code.

[0045] The processing unit 10 identifies the source code or a part thereof corresponding to the analysis result from the source code that can be identified by the file path obtained in step S103, and stores the file path and the identification data of the description part (step S108). In step S108, the processing unit 10 stores data that can identify the file path or description part of the source code for each function included in the case of the analysis result.

[0046] The processing unit 10 stores the processed cases in association with the case ID selected in step S101 (step S109) and determines whether there are any unprocessed cases (step S110). If it determines that there are unprocessed cases (S110: YES), the processing unit 10 returns to step S101 and selects another case stored in the storage 300.

[0047] If it is determined that there are no pending cases (S110: NO), the processing unit 10 performs association of cases with similar analysis results (step S111), reflects the association in the reference data R1 (step S112), and terminates the process.

[0048] In step S111, the processing unit 10 associates functions with similar outlines and objectives for each case. In step S111, the processing unit 10 may also use the function-specific outlines and objectives described in the reference data R1 analyzed for each function in step S110 to extract functions similar to those in the language model module M1 by providing prompts that include instructions for extraction.

[0049] According to the processing procedure shown in Figure 5, the functional objective or overview for each project and its association with other similar functions are stored as reference data R1. Figure 6 is an explanatory diagram showing an example of the contents of reference data R1. The reference data R1 shown in Figure 6 includes the project ID, the file path of the source code (or corresponding software development-related document), and text data indicating the objective and overview of the function implemented by the source code, all associated with a serial number (No.). The objective and overview are extracted and stored from software development-related documents, for example, from the objective and overview described in the "Specifications" document. Reference data R1 includes associations with source code or the file path of the software development-related document corresponding to that source code for implementing other functions with similar objectives and overviews.

[0050] Reference data R1 contains separate text descriptions of the purpose and overview of functions for each different source code or function, even for the same case. In the example in Figure 6, for case ID "1234", the function "Change the check performed on the purchase date to be performed on the sales date" in the source code of "Order Processing" (e.g., line number) identified by "#123" is stored from the software development related documentation. In reference data R1, the file path of the source code or corresponding software development related documentation that performs a function corresponding to the similar purpose and overview of "combining two lines into one line" (the part identified by "#45" in the source code of "Order Processing" for case "3456") is associated with this function. The same sequential number line may store the file path of the source code or corresponding software development related documentation that implements other functions with similar purposes and functions.

[0051] In the example in Figure 6, for another case with the same case ID "1234", the source code that implements the function "update content if the order unit is blank," which is described in the section identified as "#456" in the "output update" source code, is identified and stored from software development-related documents. In the reference data R1 shown in Figure 6, the file path of the source code that performs a similar function corresponding to the purpose and overview of "updating the contents of the order details to the contents of the order details" (the section identified as "#164" in the "order processing" source code for the same case) is associated with this function.

[0052] In the reference data R1 shown in Figure 6, even if the same source code contains different parts that implement different functions, data such as line numbers is stored to identify those parts. However, it is not limited to this; it may also store only the file path. Instead of the file path of the source code itself, it may store the file path of other similar software development-related documents.

[0053] The information processing device 1 periodically, or whenever the document data such as source code and software development-related documents stored in the storage 300 is updated, executes the processing procedure shown in Figure 5 on the document data, creating reference data R1 as shown in Figure 6. The reference data R1 makes it easy to identify the location of similar source code that performs similar functions based on the purpose and overview described in the software development-related documents. Furthermore, in the search process described later, the analysis result in step S107 of the processing procedure shown in Figure 5 may yield different results, i.e., may be inconsistent, due to the nature of the language model LM, if executed at different times with a time difference. Therefore, by storing it as reference data R1 as long as the original source code or document data such as software development-related documents is not updated, it is possible to expedite the search process described later and eliminate inconsistencies in the answer.

[0054] Next, we will describe the process by which the information processing device 1 presents useful source code or software development-related documents using reference data R1 when a user needs to create new source code.

[0055] Figure 7 is a flowchart illustrating an example of the procedure for presenting useful information by the information processing device 1. When a developer user uses terminal device 2 to launch terminal program P2 to search for past source code corresponding to system requirements for a certain system development project, the following process begins.

[0056] The processing unit 20 of terminal device 2 receives software development-related documents such as "development specifications," "design documents," and "requirements definition documents" corresponding to the new function, as well as requests from the user regarding those software development-related documents (step S201), based on the terminal program P2. In step S201, the processing unit 20 may also receive a specification of which function within the software development-related document should be targeted.

[0057] The processing unit 20 sends the software development-related document received in step S201 and the request to the information processing device 1 (step S202). In steps S201 and S202, the processing unit 20 may not receive and send the software development-related document itself, but rather receive input of an overview and purpose of only some of the functions that the user intends to create, and send it to the information processing device 1. The processing unit 20 may, in response to the request, extract only some of the functions from the received software development-related document before sending it. For example, the processing unit 20 may extract the "main functions" part corresponding to the request "Please provide similar source code for the main functions" from the received software development-related document and send it.

[0058] The processing unit 10 of the information processing device 1 receives software development-related documents and requests from the terminal device 2 (step S121), and converts the received software development-related documents into text data (step S122). In step S122, the processing unit 20 performs the same processing as in step S104 of the processing procedure shown in Figure 5.

[0059] The processing unit 10 uses the converted text data and the prompt received by the terminal device 2 to analyze the functions required by the software development-related document received in step S121 (step S123). In step S123, the processing unit 10 creates a prompt, for example, that instructs the language model module M1 to output the purpose and overview of the functions as the analysis result of the required functions, provides it to the language model module M1, and obtains the output analysis result.

[0060] The processing unit 10 extracts an analysis result similar to the analysis result obtained in step S123, along with the associated function or source code that implements that function, using the reference data R1, and creates a prompt that includes an instruction to be output along with the similarities and the file path of the source code or software development-related document (step S124).

[0061] The processing unit 10 provides the analysis results obtained in step S123 and the created prompt text data to the language model module M1 (step S125). In step S125, the processing unit 10 uses the language model module M1 to vectorize the prompt created in natural language and the analysis result text data, and provides the combined input data to the language model LM.

[0062] The processing unit 10 obtains the response text output from the language model module M1 (step S126) and sends the obtained response text to the terminal device 2 (step S127).

[0063] Terminal device 2 receives the response text (step S203), outputs the received response text to the screen that was received in step S201 (step S204), and terminates the process.

[0064] Figures 8 and 9 show an example of a search screen 230 based on terminal program P2. Figure 8 shows an example where a user starts terminal program P2 using terminal device 2 and displays a search screen 230 including a prompt input field 231. The search screen 230 is, for example, a web browser screen. The input field 231 is an edit control that accepts requests from the user. Adjacent to the input field 231, the search screen 230 includes an interface 232 that accepts the specification of software development-related documents. The search screen 230 sends the request entered in the input field 231 to the information processing device 1 and includes a send button 233 for sending a search request.

[0065] When the search screen 230 is displayed on the display unit 23, the user enters the requirements for the source code or software development-related document to be created into the input field 231. In the example shown in Figure 8, the text entered is, "Please provide source code that can be used as a reference for implementing the main functions in the attached document." When the user selects interface 232, uploads the target software development-related document, and presses the send button 233, the terminal device 2 executes steps S201 and S202 of the processing procedure shown in Figure 7.

[0066] Figure 9 shows the search screen 230 shown in Figure 8, after the software development-related document is specified via interface 232 and the send button 233 is selected, and the search screen 230 has been updated. If it is a web browser screen, the search screen 230 is automatically updated so that the characters of the response text are added one by one each time the information processing device 1 obtains a response text from the language model LM based on the script in the web page. The search screen 230 shown in Figure 9 includes a request field 234 that shows the text of the request most recently entered by the user, and a response field 235 that shows the text of the response text. In the search screen 230 shown in Figure 9, the response field 235 shows the result of searching for source code that implements a function similar to the main function described in the specified "Transfer Slip_Output Function Specification" by referring to reference data R1, as the response output from the language model LM. Specifically in Figure 9, the source code for case number "1234", which is extracted with serial number "1" from the reference data R1 shown in Figure 6, is presented. Although not shown in the diagram, as examples of similar documents, the source code for order processing of case number "1234" in reference data R1 shown in Figure 6, the source code for order processing of another case "3456" which has a similar purpose and overview, and the source code for other similar functions are presented.

[0067] The results shown in Figure 9 are extracted based on whether the "Purpose and Overview of Function" section, which is the result of analysis for each source code, is similar or not, and are not extracted based on the similarity of word sets obtained by full-text search within the source code or software development-related documents, which is different from conventional language model-based searches.

[0068] Even if the vocabulary used differs, other implemented source code is provided to achieve similar functions with similar purposes and outlines, as shown in Figures 6, 8, and 9. Even if the source code itself is not highly related or similar, it may be similar in terms of functionality or structure during implementation. Source code that achieves similar functions based on descriptions in software development-related documentation is provided as reference source code.

[0069] As shown in Figure 9, the basis for the similarity is explained in natural language as "similarities" based on the objectives and summaries that were deemed similar. Because similarities are presented, users who are development engineers can make a judgment to some extent about which of the presented source codes they should refer to at the time the search screen 230 is displayed.

[0070] The source code stored and updated in Storage 300 is already tested, implemented, and corrected, making it operationally viable. Providing this source code, even when using the Language Model (LM), supports software development that maintains user satisfaction and the credibility of the software developer, rather than creating a new source code foundation that unnecessarily increases man-hours.

[0071] In the first embodiment, the information processing device 1 focuses on the purpose and overview of functions described in software development-related documents such as "development specifications," "design documents," and "requirements definition documents" as reference data R1, and creates data that facilitates the extraction of source code that realizes similar functions. As shown in the first embodiment, the method of using a language model LM to extract the purpose of a document from existing document data and then presenting documents that are useful as references for newly created development support documents can be applied to other documents as well. For example, in the first embodiment, the storage 300 may store estimates, invoices, progress management, etc., related to the expenses of the software development company for a project, associated with the project ID. The information processing device 1 may create an overview from the scale of the system actually achieved in that project, the man-hours (person-months), the final invoice, etc., and store it as reference data R1, associated with the project ID. This also allows the system to be applied to a method where, if a user re-enters the customer's request (an overview or even a list) for the system (product) for which a quote has been requested into the search screen 230 and sends it to the information processing device 1, the system will then present the relevant quote, calculation results of man-hours, etc. This makes it possible to output appropriate quotes and man-hour estimates based on actual experience and for each project, while using the language model LM and reducing the risk of hallucination.

[0072] [Second Embodiment] In the development support system 100 of the second embodiment, the information processing device 1 automatically generates a portion of the source code. The configuration of the development support system 100 of the second embodiment is the same as that of the development support system 100 of the first embodiment, except for the details of the processing procedure which will be described later. Therefore, common components are denoted by the same reference numerals and detailed explanations are omitted.

[0073] In the second embodiment as well, the information processing device 1 uses a language model module M1 that includes a language model LM. The information processing device 1 performs the process of creating reference data R1, as shown in Figure 5 of the first embodiment, on the source code and software development-related documents, such as test processes, that have been completed and stored in the storage 300.

[0074] In the second embodiment, when a user is in a situation where they need to create new source code, and the terminal device 2 requests the information processing device 1 to provide source code, the information processing device 1 executes the following process.

[0075] Figure 10 is a flowchart showing an example of the information presentation process by the information processing device 1 of the second embodiment. When a user, who is a developer, starts the terminal program P2 using the terminal device 2 to search for reference information to create new source code for a system development project, the following process begins.

[0076] The processing unit 20 of terminal device 2 receives a request to generate new source code based on the terminal program P2, along with the specification of software development-related documents corresponding to the new source code (step S221). In step S221, the processing unit 20 may accept data indicating the purpose or outline of the source code design, rather than the specification of the software development-related documents themselves, such as the "development specification," "design document," and "requirements definition document."

[0077] The processing unit 20 sends the source code generation request received in step S221, along with the software development-related documents corresponding to that source code, to the information processing device 1 (step S222).

[0078] The processing unit 10 of the information processing device 1 receives a request for source code generation and software development-related documents from the terminal device 2 (step S131), and converts the received software development-related documents into text data (step S132). In step S132, the processing unit 20 performs the same processing as in step S104 shown in Figure 5 of the first embodiment. Based on the text data obtained in step S132, the processing unit 10 analyzes the required purpose or overview for the source code to be generated (step S133). If the information processing device 1 receives text data indicating the purpose or overview of the source code design instead of receiving software development-related documents in step S131, the processing in steps S132 and S133 may be omitted.

[0079] The processing unit 10 creates a prompt that includes an instruction to the language model LM to generate source code that achieves the analyzed objective or overview, based on the request received in step S131 and the analysis results in step S133 (step S134). The processing unit 10 adds an instruction to the prompt that instructs the processing unit to refer to the stored reference data R1 or the set of completed source code such as test processes stored in storage 300 as knowledge (step S135).

[0080] In step S135, the processing unit 10 may add prompts indicating the role of the language model LM, such as being an expert in software design and development in the field of the project for which the source code is based (for example, the field of ERP or core system development). In step S135, the processing unit 10 may also add prompts indicating that terminology definitions and scale information in the field for which the source code to be created is to be used as knowledge.

[0081] The processing unit 10 provides the created prompt to the language model module M1 (step S136). The processing unit 10 retrieves the source code output from the language model module M1 (step S137). The processing unit 10 then instructs the language model module M1 (language model LM) to extract the source code used as a reference for generating the source code output in step S137 from the storage 300 (step S138). The processing unit 10 identifies the file path of the extracted source code (step S139) and sends the source code output in step S137 and the file path of the reference source code identified in step S139 to the terminal device 2 (step S140).

[0082] The processing unit 20 of terminal device 2 receives the file paths of the generated source code and the reference source code (step S223). The processing unit 20 outputs the received file paths of the source code and the reference source code to the screen received in step S221 (step S224), and then terminates the process.

[0083] Figures 11 and 12 show an example of a search screen 230 based on the terminal program P2 of the second embodiment. In the second embodiment as well, the terminal device 2 displays a search screen 230, as shown in Figure 11, which includes an input field 231 and an interface 232 that accepts the specification of a target software development-related document. A user who wants to create new source code specifies a design document describing the requirements (design) for the new source code to the search screen 230 shown in Figure 11 by operating the interface 232. The user enters a request to instruct the generation of source code into the input field 231 and presses the send button 233 to the search screen 230.

[0084] In the example shown in Figure 11, the text entered reads, "Please generate source code for the implementation of the main functions in the attached document." When the user selects interface 232, uploads the target software development-related document, and presses the send button 233, terminal device 2 executes steps S221 and S222 of the processing procedure shown in Figure 9.

[0085] Figure 12 shows the search screen 230 shown in Figure 11, after a software development-related document is specified by the interface 232 and the send button 233 is selected, and the search screen 230 has been updated. If it is a web browser screen, the search screen 230 is automatically updated so that the characters of the response text are added one by one each time the information processing device 1 obtains a response text from the language model LM based on the script in the web page. In the second embodiment as well, the search screen 230 includes a request field 234 that shows the text of the request most recently entered by the user and a response field 235 that shows the text of the response text.

[0086] In the second embodiment, the answer field 235 presents a draft source code for realizing the main functions described in the specified "Transfer Voucher Output Function Specification" as an answer output from the language model LM. This draft source code is generated by the processing of steps S136 and S137 of the information processing device 1. The answer field 235 of the second embodiment further presents the file path within the storage 300 of the source code that is presumed to have been most helpful in generating the source code. The helpful source code is the source code for realizing the functions implemented in the operational system, located within the storage 300, and has already undergone testing and other processes. The helpful source code is the source code output by the language model LM at S138 of the processing procedure shown in Figure 9. The helpful source code may also be any other source code that can be identified by the processing unit 10 using reference data R1 as source code with a similar purpose or overview of the function. The similarity judgment here may be evaluated by combining linguistic similarity such as full-text search and clustering.

[0087] Thus, in the second embodiment, not only can source code be searched from storage 300, but source code that conforms to the required specifications, definitions, purposes, or outlines for the source code can also be generated as knowledge from the source code in storage 300. In this case, the generated and presented source code has not undergone testing or other processes. However, in the development support system 100 of this disclosure, similar source code that has already undergone testing and other processes is presented together with the generated source code, so that the user, who is a development engineer, can work while being aware of the differences and how to write and construct the actual source code. This makes it possible to achieve more efficient software development that makes use of the source code on storage 300, which remains as intellectual property, rather than generating source code by inputting text indicating definitions and system requirements into the prompts of a so-called generation AI.

[0088] As described above, the presentation of implemented source code by the development support system 100 applies not only to the source code of the software program itself, but also to test scenarios for the software program and test code that automatically executes tests. When a software program implements a system that provides a GUI, it is necessary to implement a vast amount of test code for various environments in order to support E2E (End to End) testing to test whether it operates similarly in diverse client environments. In such cases, rather than generating test code from scratch using generation AI, the development support system 100 disclosed herein enables more efficient test engineering by presenting useful test code from a vast amount of similar test code, including already proven test code.

[0089] The embodiments disclosed above are illustrative in all respects and not restrictive. The scope of the present invention is indicated by the claims, and all modifications within the meaning and scope equivalent to the claims are included. [Explanation of symbols]

[0090] 100 Development Support Systems 1. Information Processing Device 10 Processing Unit 11 Storage section P1 Information Processing Program LM Language Model 2 Terminal devices 23 Display section

Claims

1. On the computer, Analyze the documentation data regarding the functional design of each of the multiple implemented source code files stored in the storage. For each of the multiple implemented source code implementations, reference data is created that includes text indicating the purpose or overview of the function identified based on the analysis of the document data, and an association with other implemented source code implementations that implement similar functions. We analyze data related to the functional design of the new source code, Based on the analysis results, the implemented source code that implements a function similar to the function identified is identified from the storage using the reference data. Output the identified implemented source code along with the similarities to the aforementioned functions. A computer program that executes a process.

2. To the aforementioned computer, The language model is provided with documentation data relating to the functional design of each of the aforementioned multiple implemented source code files. The language model outputs text indicating the purpose or overview of the function described in the document data. A computer program according to claim 1, which causes a process to be executed.

3. To the aforementioned computer, The language model is provided with text indicating the purpose or overview of each of the functions of the multiple implemented source code files that has been output. The language model outputs data indicating the association between each of the functions of the multiple implemented source code files and other implemented source code files that implement similar functions. A computer program according to claim 2, which causes a process to be executed.

4. With respect to the aforementioned document data, knowledge data related to the development of the multiple implemented source codes is selected, The selected knowledge data is provided to the language model along with the document data. A computer program according to claim 2 or 3, which causes a process to be executed.

5. The aforementioned document data includes a chart or a captured image of a GUI screen. To the aforementioned computer, Extract text from the aforementioned diagram or the aforementioned captured image, The extracted text is provided to the language model along with the text contained in the document data. A computer program according to claim 2 or 3, which causes a process to be executed.

6. To the aforementioned computer, The language model is given data relating to the functional design of the new source code and instructions that instruct the generation of the new source code. The system outputs a draft of the new source code generated from the language model, along with the identified implemented source code for the new source code. A computer program according to claim 1, which causes a process to be executed.

7. To the aforementioned computer, Based on the analysis results of the new source code, the implemented source code that implements functions similar to those identified, is identified from the storage using the reference data. This result is then provided to the language model as knowledge data, in addition to the instruction statement that instructs the generation of the new source code. A computer program according to claim 6, which causes a process to be executed.

8. Analyze the documentation data regarding the functional design of each of the multiple implemented source code files stored in the storage. For each of the multiple implemented source code implementations, reference data is created that includes text indicating the purpose or overview of the function identified based on the analysis of the document data, and an association with other implemented source code implementations that implement similar functions. We analyze data related to the functional design of the new source code, Based on the analysis results, the implemented source code that realizes the function and similar functions is identified from the storage using the reference data. Output the identified implemented source code along with the similarities to the aforementioned functions. An information processing device equipped with a processing unit.

9. Computers Analyze the documentation data regarding the functional design of each of the multiple implemented source code files stored in the storage. For each of the multiple implemented source code implementations, reference data is created that includes text indicating the purpose or overview of the function identified based on the analysis of the document data, and an association with other implemented source code implementations that implement similar functions. We analyze data related to the functional design of the new source code, Based on the analysis results, the implemented source code that realizes the function and similar functions is identified from the storage using the reference data. Output the identified implemented source code along with the similarities to the aforementioned functions. Information processing methods.

Images