Information processing device, information processing method, and program

Abstract

To adjust and manage information on a change history in software development.SOLUTION: In an information processing device, data acquisition means acquires change history data on a change in software. Prompt acquisition means acquires a prompt described in a natural language to command creation of an understanding table from the change history data. Table creation means interprets the prompt by using a natural language model, and creates an understanding table on the basis of the change history data. Storage means stores the understanding table in a storage unit.SELECTED DRAWING: Figure 4

Description

Technical Field

[0001] The present disclosure relates to software development support.

Background Art

[0002] Git is known as a system used when multiple users collaborate on software development. Git is a distributed version control system for recording and tracking the change history of program source code and the like. Patent Document 1 discloses a software development technique using Git.

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] When developing software jointly by multiple users, by using Git or the like, it is possible to leave a history of changes and edits made by individual users. However, when the number of updates increases, it becomes necessary to track a large number of change histories in order to confirm the purpose and content of individual changes. The same applies to software development by a single user when the number of changes is large or when a long time has passed since the latest update.

[0005] One object of the present invention is to organize and manage information regarding change history in software development.

Means for Solving the Problems

[0006] In one aspect of the present disclosure, an information processing apparatus includes data acquisition means for acquiring change history data regarding changes to software, Prompt acquisition means for acquiring a prompt described in natural language and instructing to create an understanding table from the change history data; Table creation means for interpreting the prompt using a natural language model and creating an understanding table based on the change history data; Storage means for storing the understanding table in a storage unit; It is provided with.

[0007] In another aspect of the present disclosure, an information processing method is executed by a computer, Obtain change history data regarding software changes, Obtain a prompt described in natural language and instructing to create an understanding table from the change history data, Interpret the prompt using a natural language model, create an understanding table based on the change history data, Store the understanding table in a storage unit.

[0008] In still another aspect of the present disclosure, a program, Obtain change history data regarding software changes, Obtain a prompt described in natural language and instructing to create an understanding table from the change history data, Interpret the prompt using a natural language model, create an understanding table based on the change history data, Cause the computer to execute a process of storing the understanding table in a storage unit.

Effect of the Invention

[0009] According to the present disclosure, in software development, it becomes possible to organize and manage information regarding change history.

Brief Description of the Drawings

[0010]

Figure 1

Figure 2

Figure 3

Figure 4

Figure 5

Figure 6

Figure 7

Figure 8

Figure 9

Figure 10

Figure 11

Figure 12

Figure 13

Figure 14

Figure 15

Figure 16

[0011] Hereinafter, with reference to the drawings, preferred embodiments of the present disclosure will be described. <First Embodiment> [Overall Configuration] FIG. 1 shows the overall configuration of a software development support system (hereinafter simply referred to as the "development support system") to which the information processing apparatus according to the present disclosure is applied. Developers of software and the like (hereinafter also simply referred to as "users") make changes and edits to program codes and the like during software development. In the present embodiment, it is assumed that a plurality of users collaborate to develop software using Git.

[0012] As shown in FIG. 1, the development support system 1 includes a server device 10 and a plurality of terminal devices 20. The server device 10 and the terminal devices 20 can communicate with each other via a wired or wireless network.

[0013] The server device 10 manages a remote repository in Git. Although details will be described later, the server device 10 creates and manages an understanding table based on the change history data obtained from the remote repository based on a user's instruction.

[0014] The terminal device 20 is operated by a user who develops software. The user creates a local repository on the terminal device 20 and makes necessary changes and edits to the source code of the program and the like. Then, the user registers the changed files and directories with the server device 10. This operation is called a commit. When the user makes a commit, a commit history that records the difference from the previous commit to the present is generated in the remote repository in the server device 10. By each user making changes and edits to their respective areas of responsibility and committing them to the local repository of the server device 10, software development by a plurality of users can proceed. The commit history is an example of the change history of software.

[0015] As multiple users perform software modification operations, a plurality of change histories are accumulated in the server device 10. Each user can know the content of the changes made by themselves or other users by referring to the change history stored in the server device 10. However, when the number of change histories becomes extremely large or when the description rules of the change histories are not unified, etc., tracking the change content becomes complicated. Therefore, in this embodiment, the change history data stored in the server device 10 is sorted using a natural language model to generate an understanding table, which is then stored in a database or the like of the server device 10. Specifically, the server device 10 uses a natural language model to generate an understanding table described in natural language from the change history data and stores it in the database. As a result, the user can easily obtain information regarding past changes and edits by making a natural language query to the server device 10.

[0016] Details will be described later, but the server device 10 is equipped with a natural language model that can interpret natural language. The user sends a prompt described in natural language to the server device 10. At this time, the user includes in the prompt the specification of the target change history data and an instruction to create an understanding table. A "prompt" refers to an instruction text to a generative AI (Artificial Intelligence) including a natural language model or the like. The server device 10 receives the prompt, interprets the prompt using the natural language model, and recognizes the specification of the change history data by the user and the instruction to create an understanding table. Then, the server device 10 uses the natural language model to create an understanding table from the change history data and stores it in the database.

[0017] [Natural Language Model] Here, a natural language model will be described. A natural language model is one that learns the relationships between words in a sentence and is a model that generates related strings related to the target string from the target string. By using a natural language model that has learned sentences and texts in various contexts, it is possible to generate related strings with appropriate content related to the target string. For example, the case of using a natural language model in question-and-answer will be described. In this case, the natural language model accepts the input of the question "What kind of country is Japan?" as the target string and generates strings such as "Japan is an island country in the Northern Hemisphere..." as the answer to the question.

[0018] The learning method of the natural language model is not particularly limited. As an example, it may be one that is learned to output at least one sentence including the input string. For a specific example, the natural language model can be GPT (Generative Pre-Training) that outputs a sentence including the input string by predicting the string with a high probability following the input string. In addition to this, as the natural language model, for example, T5 (Text-to-Text Transfer Transformer), BERT (Bidirectional Encoder Representations from Transformers), RoBERTa (Robustly optimized BERT approach), ELECTRA (Efficiently Learning an Encoder that Classifies Token Replacements Accurately), etc. can also be used. In this embodiment, a large language model may be used as the natural language model. Also, the natural language model may be one that can access the Internet or other specialized knowledge bases to obtain information.

[0019] [Hardware Configuration] (Server Device) Figure 2 is a block diagram showing the hardware configuration of the server device 10. As shown in the figure, the server device 10 includes a processor 11, an interface (IF) 12, a ROM (Read Only Memory) 13, a RAM (Random Access Memory) 14, a database (DB) 15, and a recording medium 16. Each component is connected to each other through, for example, a bus 18.

[0020] The processor 11 is a computer such as a CPU (Central Processing Unit), and controls the entire server device 10 by executing a pre-prepared program. Specifically, as the processor 11, a CPU, a GPU (Graphics Processing Unit), a DSP (Digital Signal Processor), an MPU (Micro Processing Unit), an FPU (Floating Point number Processing Unit), a PPU (Physics Processing Unit), a TPU (TensorProcessingUnit), a quantum processor, a microcontroller, or a combination thereof can be used.

[0021] The processor 11 loads the programs stored in the ROM 13 and the recording medium 16 into the RAM 14, and executes each process coded in the programs. The processor 11 functions as part or all of the server device 10.

[0022] The IF 12 transmits and receives data to and from an external device. Specifically, the server device 10 transmits and receives information to and from the terminal device 20 through the IF 12.

[0023] The ROM 13 stores various programs to be executed by the processor 11. The RAM 14 is used as a working memory during the execution of various processes by the processor 11. The DB 15 stores the change history data created by each user during software development. Also, the DB 15 stores various understanding tables generated by the server device 10 based on the change history data. Note that the understanding tables will be described later.

[0024] The recording medium 16 is a non-volatile and non-transitory recording medium such as a disk-shaped recording medium or a semiconductor memory. The recording medium 16 may be configured to be detachable from the server device 10. The recording medium 16 stores various programs executed by the processor 11.

[0025] (Terminal device) FIG. 3 is a block diagram showing the hardware configuration of the terminal device 20. The terminal device 20 is, for example, a PC or a tablet terminal. As shown in the figure, the terminal device 20 includes a processor 21, an IF 22, a ROM 23, a RAM 24, a recording medium 25, an input unit 26, and a display unit 27. Each component is connected to each other, for example, through a bus 28.

[0026] The processor 21 is a computer such as a CPU, and controls the entire terminal device 20 by executing a pre-prepared program. Note that the processor 21 may be a GPU, an FPGA, a DSP, an ASIC, or the like.

[0027] The IF 22 transmits and receives data to and from an external device. Specifically, the terminal device 20 transmits, through the IF 22, to the server device 10 the change history data created by the user during software development, a prompt including an instruction to create an understanding table, and the like.

[0028] The ROM 23 stores various programs to be executed by the processor 21. Also, the RAM 24 is used as a working memory during the execution of various processes by the processor 21.

[0029] The recording medium 25 is a non-volatile and non-temporary recording medium such as a disk-shaped recording medium or a semiconductor memory. The recording medium 25 may be configured to be detachable from the terminal device 20. The recording medium 25 stores various programs executed by the processor 21.

[0030] The input unit 26 is an input device such as a keyboard, a mouse, or a touch panel, for example. The user inputs a prompt including an instruction to create an understanding table and questions regarding the software under development by operating the input unit 26. The display unit 27 is a display or the like that performs display based on the control of the processor 21. Answers to the questions input by the user are displayed on the display unit 27 and presented to the user.

[0031] [Functional Configuration] FIG. 4 is a block diagram showing the functional configuration of the server device 10. The server device 10 functionally includes an information processing unit 19. Also, the DB 15 includes a change history DB 30 and an understanding table DB 40. The understanding table DB 40 includes a release note understanding table 41, a commit history understanding table 42, a branch history understanding table 43, a folder structure understanding table 44, and a dependency understanding table 45.

[0032] The change history DB 30 stores change history data. The change history data is data stored in the repository in the server device 10 when each user makes changes or edits to the software using Git. Specifically, the change history data includes release note data, commit history data, branch history data, folder structure data, etc. as data generated in program development.

[0033] The information processing unit 19 generates an understanding table based on a prompt from the user. The understanding table refers to a table for explaining the meaning and relevance of data in a database. The information processing unit 19 stores the generated understanding table in the understanding table DB40. As shown in FIG. 4, in this embodiment, the understanding table includes a release note understanding table 41, a commit history understanding table 42, a branch history understanding table 43, a folder structure understanding table 44, and a dependency understanding table 45.

[0034] Specifically, the information processing unit 19 obtains the prompt input by the user to create the understanding table. This prompt includes the specification of the data to be the target of creating the understanding table and an instruction to create an understanding table for that data. For example, when creating an understanding table for the commit history, the user inputs a prompt such as "Please create an understanding table for the commit history using the commit history data."

[0035] The information processing unit 19 includes a natural language model. The information processing unit 19 interprets the prompt using the natural language model and obtains the specified data from the change history DB30. Next, the information processing unit 19 organizes the obtained data for each item of the understanding table to be created to create the understanding table and stores it in the understanding table DB40. In this way, an understanding table for various data is generated. Each understanding table is a table that organizes each change history data to explain its meaning and relevance. Therefore, by referring to each understanding table, it is easier to know the details of the changes made by each user than to track the change history data in the change history DB30.

[0036] [Example of understanding table] Next, an example of the understanding table will be described. Now, as an example of the prerequisite software development, consider a project "Project_A" to develop a machine learning model for predicting the demand for product A. The machine learning model for predicting the demand for product A (hereinafter simply referred to as the "demand prediction model") is assumed to have Ver.1.1 created based on the first version, Ver.1.0. Figure 5 shows the folder structures of Ver.1.0 and Ver.1.1 of the demand prediction model. Note that the files changed in Ver.1.1 are underlined in the folder structure of Ver.1.1. The change history data related to Ver.1.0 and Ver.1.1 is stored in the change history DB30.

[0037] When creating the release note understanding table, the user creates a prompt P1 as shown in, for example, Fig. 11(A) and sends it to the server device 10. The prompt P1 designates release note data as the target data and includes an instruction to create a release note understanding table. The information processing unit 19 of the server device 10 interprets the prompt P1 using a natural language model and acquires the release note data of Project_A from the change history DB30. Then, the information processing unit 19 organizes the acquired release note data into a table, creates a release note understanding table 41, and stores it in the understanding table DB40. If there is already an old release note understanding table 41, the information processing unit 19 may update the release note understanding table 41 using the created release note understanding table.

[0038] Figure 6 shows an example of the release note understanding table. The release note understanding table 41 includes, as items, "release version", "branch source version", "release date and time", and "summary". Note that "branch" refers to the program code created by branching from the main history for the development of different versions or functions of a project, or the process of creating it.

[0039] When creating a commit history understanding table, the user creates, for example, a prompt P2 shown in FIG. 11(B) and sends it to the server device 10. The prompt P2 designates commit history data as target data and includes an instruction to create a commit history understanding table. The information processing unit 19 interprets the prompt P2 using a natural language model and acquires the commit history data of Project_A from the change history DB30. Then, the information processing unit 19 organizes the acquired commit history data into a table, creates a commit history understanding table 42, and stores it in the understanding table DB40. If there is already an old commit history understanding table 42, the information processing unit 19 may update the commit history understanding table 42 using the created commit history understanding table.

[0040] FIG. 7 shows an example of a commit history understanding table. The commit history understanding table 42 includes, as items, "commit ID", "commit date and time", "committer", "summary", and "purpose". The "commit ID" is identification information for the commit operation, the "commit date and time" is the date and time when the commit was made, and the "committer" is identification information for the user who performed the commit operation. The "summary" is the work content of each commit, and the "purpose" indicates the purpose for which the committer made the commit. Note that the information processing unit 19 can generate the "summary" and "purpose" based on the commit messages included in the Git commit history.

[0041] If the user wants to specify the structure of the understanding table to be created, specifically the items included in the understanding table, the user can include the specification of the items in the prompt. For example, if the user wants to create a commit history understanding table as illustrated in FIG. 7, the user can specify the items to be included in the understanding table in the prompt as in the prompt P3 in FIG. 11(C). In this case, the information processing unit 19 may create the understanding table by extracting and organizing the data corresponding to the items specified in the prompt from the change history data.

[0042] When creating a branch history understanding table, the user creates a prompt P4 as shown in FIG. 11(D), for example, and sends it to the server device 10. The prompt P4 designates branch history data as target data and includes an instruction to create a branch history understanding table. The information processing unit 19 interprets the prompt P4 using a natural language model, and acquires the branch history data of Project_A from the change history DB30. Then, the information processing unit 19 organizes and tabulates the acquired branch history data, creates a branch history understanding table 43, and stores it in the understanding table DB40. If an old branch history understanding table 43 already exists, the information processing unit 19 may update the branch history understanding table 43 using the created branch history understanding table.

[0043] FIG. 8 shows an example of a branch history understanding table. The branch history understanding table 43 includes, as items, "branch name", "latest commit date and time", "committer", "role", and "remarks". The "branch name" is the name given to the branch, the "latest commit date and time" is the date and time when the latest commit was made in each branch, and the "committer" is the identification information of the user who performed the commit operation. The "role" indicates the role of the branch, and the "remarks" are supplementary explanations for each branch.

[0044] When creating a folder structure understanding table, the user creates a prompt P5 as shown in FIG. 12(A), for example, and sends it to the server device 10. The prompt P5 designates folder structure data as target data and includes an instruction to create a folder structure understanding table. The information processing unit 19 interprets the prompt P5 using a natural language model, and acquires the folder structure data of Project_A from the change history DB30. Then, the information processing unit 19 organizes and tabulates the acquired folder structure data, creates a folder structure understanding table 44, and stores it in the understanding table DB40. If an old folder structure understanding table 44 already exists, the information processing unit 19 may update the folder structure understanding table 44 using the created folder structure understanding table.

[0045] FIG. 9 shows an example of a folder structure understanding table. The folder structure understanding table 44 includes, as items, "Name", "Folder", "Parent Folder", "Contents", "Defined Variables, Functions, Classes", "Ver. 1.1 (Dependency)", and "Ver. 1.0 (Dependency)". "Name" is the name of the folder or file. "Folder" indicates the identification of a folder and a file. Specifically, "Y" indicates a folder, and "[N]" indicates a file. Whether it is a folder or a file can be determined from, for example, the properties of the file system. "Parent Folder" indicates the name of the parent folder of the folder. "Contents" indicates the description of the data stored in the folder or file or the use of the folder or file. "Defined Variables, Functions, Classes" indicates the variables, functions, or classes defined in the file. "Ver. 1.1 (Dependency)" and "Ver. 1.0 (Dependency)" indicate the dependency relationship and correspondence relationship between the versions of each folder or file.

[0046] When creating a dependency relationship understanding table, the user creates, for example, a prompt P6 shown in FIG. 12(B) and sends it to the server device 10. The prompt P6 designates a project as target data and includes an instruction to create a dependency relationship understanding table. The information processing unit 19 interprets the prompt P6 using a natural language model and acquires variable data, function data, and class data for the designated project from the change history DB 30. Then, the information processing unit 19 organizes the acquired data into a table, creates a dependency relationship understanding table 45, and stores it in the understanding table DB 40. If there is already an old dependency relationship understanding table 45, the information processing unit 19 may update the dependency relationship understanding table 45 using the created dependency relationship understanding table.

[0047] FIG. 10 shows an example of a dependency understanding table. The dependency understanding table 45 includes, as items, "author", "variable / function / class name", "type", "dependency", and "meaning / processing". "Author" is the identification information of the creator of the variable, function, or class. "Variable / function / class name" is the name of the variable, function, or class. "Type" is the data type of the variable. "Dependency" indicates the dependency relationship with other variables, functions, or classes. "Meaning / processing" indicates the meaning of the variable, function, or class and the processing using it.

[0048] As described above, in this embodiment, when changes or edits are made to the program using Git, the server device 10 creates and saves an understanding table from the change history data accumulated at different viewpoints such as the commit history and the folder structure. As a result, the information processing unit 19 understands the content of the change history DB 30, that is, the Git repository, in the form of an understanding table, and thereafter the user can make inquiries and requests regarding the Git repository to the information processing unit 19.

[0049] [Understanding Table Creation Process] FIG. 13 shows a flowchart of the understanding table creation process. The understanding table creation process is a process of creating an understanding table based on the change history data as described above. This process is realized by the processor 11 shown in FIG. 2 executing a program prepared in advance and operating as the information processing unit 19 shown in FIG. 4. The understanding table creation process is executed when creating a new understanding table and when updating or revising an existing understanding table. Note that "update" means overwriting and creating a created understanding table with a new understanding table. Also, "revision" means creating a new understanding table (corresponding to, for example, Ver. 1.1) while leaving the created understanding table (corresponding to, for example, Ver. 1.0).

[0050] First, when the user inputs a prompt, the information processing unit 19 receives the input prompt (step S51). Next, the information processing unit 19 acquires the data specified in the prompt from the change history DB30, creates an understanding table, and stores it in the understanding table DB40 (step S52). Note that when creating a certain understanding table, the information processing unit 19 may refer to other created understanding tables. Then, the understanding table creation process ends.

[0051] [Example of using the understanding table] Next, an example of using the understanding table will be described. The understanding table is described in natural language, and the information processing unit 19 of the server device 10 is equipped with a natural language model. Therefore, the information processing unit 19 can receive questions and inquiries described in natural language from the user, refer to the understanding table to generate an answer, and send it to the user. As a result, even when a user who is not familiar with program code wants to know the status of software development, it is possible to ask questions in natural language to the server device 10.

[0052] For example, when wanting to know the difference between Ver.1.0 and Ver.1.1 in the above-mentioned Project_A, the user generates a question prompt P7 as shown in FIG. 14(A) and sends it to the server device 10. The prompt P7 is asking about the difference between Ver.1.0 and Ver.1.1 in the above-mentioned Project_A. When receiving this prompt P7, the information processing unit 19 refers to the release note understanding table shown in FIG. 6, the commit history understanding table shown in FIG. 7, the folder structure understanding table shown in FIG. 9, etc., and knows that "Ver.1.1 is based on Ver.1.1 and learned by adding the weekday / holiday flag as a feature quantity", and can answer as shown in FIG. 14(A).

[0053] Also, as shown in FIG. 14(B), when the user asks a question regarding the accuracy of Ver.1.0 and Ver.1.1, the information processing unit 19 refers to the release note understanding table shown in FIG. 6, etc., and knows that "the RMSE has improved from 75% to 82%", and can answer as shown in FIG. 14(B).

[0054] As another example, the user can also specify a specific commit by a commit ID, a commit date and time, etc., and ask about the purpose of the commit, or specify a certain variable or class and ask about the meaning of the variable or class.

[0055] Also, by giving a specific processing function to the natural language model included in the information processing unit 19, it is also possible to request specific processing regarding the understanding table. For example, a function for organizing (refactoring) a folder structure or files is given to the natural language model included in the information processing unit 19. The user gives an instruction for refactoring regarding a specific folder or the entire folder structure in the change history DB30 by a prompt. When the information processing unit 19 receives an instruction for refactoring the folder structure, it can understand the folder structure in the change history DB30 with reference to a folder structure understanding table or the like, and perform refactoring.

[0056] [Modification Example] Next, a modification example of the above embodiment will be described. The following modification examples can be applied in appropriate combinations.

[0057] (Modification Example 1) In the above embodiment, a plurality of users are collaborating to change and edit a program, etc., but even when a single user changes and edits a program, etc., this embodiment can be similarly applied.

[0058] (Modification Example 2) In the above embodiment, Git is used as the software development support system, but any other system can be used as long as it accumulates histories of program changes, edits, etc.

[0059] <Second Embodiment> FIG. 15 is a block diagram showing a functional configuration of an information processing apparatus according to the second embodiment. The information processing apparatus 70 includes a data acquisition unit 71, a prompt acquisition unit 72, a table creation unit 73, and a storage unit 74.

[0060] Figure 16 is a flowchart of the processing by the information processing apparatus according to the second embodiment. The data acquisition means 71 acquires change history data regarding software changes (step S71). The prompt acquisition means 72 acquires a prompt described in natural language and instructing to create an understanding table from the change history data (step S72). The table creation means 73 interprets the prompt using a natural language model and creates an understanding table based on the change history data (step S73). The storage means 74 stores the understanding table in the storage unit (step S74).

[0061] According to the information processing apparatus 70 of the second embodiment, it is possible to organize and manage information regarding change history in software development.

[0062] Some or all of the above embodiments may be described as follows in the following supplementary notes, but are not limited thereto.

[0063] (Supplementary Note 1) Data acquisition means for acquiring change history data regarding software changes, Prompt acquisition means for acquiring a prompt described in natural language and instructing to create an understanding table from the change history data, Table creation means for interpreting the prompt using a natural language model and creating an understanding table based on the change history data, Storage means for storing the understanding table in a storage unit, An information processing apparatus comprising.

[0064] (Supplementary Note 2) The information processing apparatus according to Supplementary Note 1, wherein the understanding table includes an understanding table of the change history of the software and an understanding table of a folder structure storing data related to the software.

[0065] (Supplementary Note 3) The change history data is generated using Git, The understanding table is the information processing apparatus according to Appendix 1 including a commit history understanding table and a folder structure understanding table.

[0066] (Appendix 4) The understanding table is the information processing apparatus according to Appendix 3 including a release note understanding table and a branch history understanding table.

[0067] (Appendix 5) The understanding table is the information processing apparatus according to Appendix 4 including a dependency relationship understanding table showing the dependency relationships of variables, functions, and class names.

[0068] (Appendix 6) The prompt is the information processing apparatus according to Appendix 1 including the specification of items to be included in the created understanding table.

[0069] (Appendix 7) The understanding table is described in natural language, a question acquisition means for acquiring a question described in natural language, an answer means for interpreting the question using a natural language model, generating and outputting an answer to the question by referring to the understanding table, and the information processing apparatus according to Appendix 1 comprising the same.

[0070] (Appendix 8) The understanding table includes a folder structure understanding table described in natural language, a question acquisition means for acquiring an instruction described in natural language for organizing the folder structure, an organizing means for interpreting the instruction using a natural language model and organizing the folder structure of the change history data, and the information processing apparatus according to Appendix 1 comprising the same.

[0071] (Appendix 9) executed by a computer, acquiring change history data regarding changes in software, Obtain a prompt described in natural language that instructs to create an understanding table from the change history data, Interpret the prompt using a natural language model and create an understanding table based on the change history data, An information processing method for storing the understanding table in a storage unit.

[0072] (Appendix 10) Obtain change history data regarding software changes, Obtain a prompt described in natural language that instructs to create an understanding table from the change history data, Interpret the prompt using a natural language model and create an understanding table based on the change history data, A program that causes a computer to execute a process of storing the understanding table in a storage unit.

[0073] Although the present disclosure has been described with reference to embodiments and examples, the present disclosure is not limited to the above embodiments and examples. Various changes that can be understood by those skilled in the art can be made to the configuration and details of the present disclosure within the scope of the present disclosure.

Explanation of Reference Numerals

[0074] 10 Server device 11 Processor 19 Information processing unit 20 Terminal device 30 Change history DB 40 Understanding table DB 41 Release note understanding table 42 Commit history understanding table 43 Branch history understanding table 44 Folder structure understanding table 45 Dependency understanding table

Claims

1. Data acquisition means for acquiring change history data regarding software changes, Prompt acquisition means for acquiring a prompt described in natural language and instructing to create an understanding table from the change history data, Table creation means for interpreting the prompt using a natural language model and creating an understanding table based on the change history data, Storage means for storing the understanding table in a storage unit, An information processing apparatus comprising:

2. The information processing apparatus according to claim 1, wherein the understanding table includes an understanding table of the software change history and an understanding table of a folder structure storing data related to the software.

3. The change history data is generated using Git, The information processing apparatus according to claim 1, wherein the understanding table includes a commit history understanding table and a folder structure understanding table.

4. The information processing apparatus according to claim 3, wherein the understanding table includes a release note understanding table and a branch history understanding table.

5. The information processing apparatus according to claim 4, wherein the understanding table includes a dependency relationship understanding table showing the dependency relationships of variables, functions, and class names.

6. The information processing apparatus according to claim 1, wherein the prompt includes a specification of items to be included in the created understanding table.

7. The understanding table is described in natural language, Question acquisition means for acquiring a question described in natural language, Answer means for interpreting the question using a natural language model, generating and outputting an answer to the question by referring to the understanding table, The information processing apparatus according to claim 1, comprising:

8. The understanding table includes a folder structure understanding table described in natural language, Question acquisition means for acquiring an instruction in natural language to organize the folder structure, Organizing means for interpreting the instruction using a natural language model and organizing the folder structure of the change history data, The information processing apparatus according to claim 1, comprising:

9. Executed by a computer, Acquiring change history data regarding software changes, Acquiring a prompt described in natural language and instructing to create an understanding table from the change history data, Interpreting the prompt using a natural language model, creating an understanding table based on the change history data, An information processing method for storing the understanding table in a storage unit.

10. Obtain change history data regarding software changes, obtain a prompt described in natural language that instructs to create an understanding table from the change history data, interpret the prompt using a natural language model, create an understanding table based on the change history data, A program that causes a computer to execute a process of storing the understanding table in a storage unit.

Images