Software product multi-version parallel development method based on large language model

Abstract

The invention discloses a software product multi-version parallel development method based on a large language model, and the method comprises the steps: receiving a software multi-version development request, and generating a multi-version demand model through natural language processing and analysis; constructing a training data set containing version difference information based on the multi-version demand model, and performing fine tuning on the large language model in combination with the instruction template to obtain a target large language model adapted to multi-version development; double storage spaces are configured for each software design stage, and initial design achievements and final design achievement storage of all versions are processed in parallel; generating, complementing and optimizing intelligent codes of all versions by utilizing a target large language model; design and code conflicts among multiple versions are detected in real time and intelligently coordinated and solved; and integration verification of all versions is completed through combination of automatic testing and manual testing. According to the method, parallel efficient development of multi-version software is realized, the code generation accuracy is improved, and the development cost caused by demand change and version conflict is reduced.

Description

Technical Field

[0001] This application relates to the field of software development technology, specifically to a method for parallel development of multiple versions of software products based on a large language model. Background Technology

[0002] In the software development process, to meet the needs of different user groups or adapt to market iterations, it is often necessary to develop multiple versions of the software product simultaneously. Current technologies for parallel software development largely rely on the branch management of version control systems, but these systems lack intelligent support for multi-version requirement analysis, design, and code generation.

[0003] While existing large language models have applications in code generation, they are mostly designed for single-version development scenarios and cannot adapt to the common and differentiated requirements of multiple versions, resulting in insufficient accuracy in code generation. Furthermore, in multi-version development, frequent requirement changes and difficulties in quickly coordinating conflicts between versions lead to low efficiency in the transfer of deliverables from each design phase. In addition, code writing and optimization rely on human experience, resulting in long software development cycles, high costs, and difficulty in guaranteeing software quality.

[0004] Furthermore, existing parallel development methodologies lack an effective mechanism for separating the storage of deliverables from each design phase. When version requirements change rapidly, issues arise regarding untimely file updates, further impacting the efficiency and stability of multi-version development. Therefore, there is an urgent need for a parallel development methodology that can integrate the advantages of large language models to achieve intelligent parsing of multi-version requirements, efficient code generation, and rapid conflict resolution. Summary of the Invention

[0005] In view of the shortcomings of the existing technology, the purpose of this invention is to provide a method for parallel development of multiple versions of software products based on a large language model, so as to solve the problems mentioned in the background technology.

[0006] According to one aspect of this application, a method for parallel development of multiple versions of a software product based on a large language model includes the following steps:

[0007] Step 1: Receive multiple software version development requests, analyze the development requirements of each version using natural language processing algorithms, extract the key requirements, functional requirements and constraints of each version, and generate a multi-version requirement model.

[0008] Step 2: Based on the multi-version requirement model, extract the common requirements and differentiated features of each version, construct a training dataset containing natural language statements, corresponding code and version difference identifiers, and obtain instruction templates for instructing the generation of multi-version code; fill the training dataset into the instruction templates to form a training instruction set, and use the training instruction set to fine-tune the initial large language model to obtain the target large language model adapted for parallel development of multiple versions.

[0009] Step 3: Configure a first storage space and a second storage space for each software design stage. The first storage space is used to store the initial design results of each version, and the second storage space is used to store the final design results of each version. Based on the multi-version requirement model and the target large language model, generate the initial design results of each version in parallel and store them in the corresponding first storage space.

[0010] Step 4: Optimize and improve the initial design results of each version to form the final design results and store them in the corresponding second storage space. During this process, the target large language model is used to complete the intelligent code generation, completion and optimization of each version.

[0011] Step 5: Real-time detection of conflicts between different versions at the design and code levels, and intelligent analysis based on preset rules and target large language model to coordinate and resolve conflicts.

[0012] Step 6: Submit the final code of each version to the version control system. After code review and iteration, complete the integration verification through a combination of automated and manual testing, and output the software product of each version.

[0013] Preferably, in step three, the software design phase includes conceptual model design, business domain design, application service design, technical architecture design, development architecture design, data architecture design, application deployment design, and application detailed design. The first storage space and the second storage space of each software design phase are independently associated with each version identifier.

[0014] Preferably, in step two, the step of constructing the training dataset includes: determining the domain keywords of the target domain and the corresponding database table creation statements based on the common requirements and differentiated features of each version; generating statement data pairs using the domain keywords, table creation statements, and the second instruction template, each statement data pair containing a natural statement, corresponding code, and version difference identifier; and deduplicating the statement data pairs to form the training dataset.

[0015] Preferably, in step two, the instruction template includes a task description, constraints, a table creation statement input field, a natural language statement input field, a code input field, and a version identifier input field, wherein the code is at least one of SQL code and programming language code.

[0016] Preferably, in step four, the steps of using the target large language model to complete intelligent code generation, completion, and optimization include: inputting the final design results of each version into the target large language model to generate an initial code framework; based on the functional details and performance requirements of the version, completing the missing parts of the code and correcting erroneous code through the target large language model; analyzing the structure, logic implementation, error handling, and performance bottlenecks of the code, outputting optimization suggestions, and completing code optimization.

[0017] Preferably, in step five, the step of real-time detection of conflicts between multiple versions includes: comparing the data structure, code logic, and interface definitions of the design results of different versions through the target large language model; identifying conflict points such as data dependency conflicts, logical conflicts, and interface incompatibilities; generating conflict solutions based on the priority and requirement constraints of each version, and coordinating and adjusting the design results and code of the relevant versions.

[0018] Preferably, if new version requirements are added or existing version requirements are changed during the development process, the new or changed requirements are parsed and the multi-version requirement model is updated; the training dataset is supplemented based on the updated multi-version requirement model, and the target large language model is incrementally fine-tuned; the design results and code of the corresponding version are updated synchronously, and the conflict detection and coordination steps are re-executed.

[0019] Preferably, in step six, the steps of combining automated testing and manual testing include: developing a test plan based on the requirement model of each version, writing automated test scripts that cover key functions and boundary conditions, and designing manual test cases for complex interactions and user experience; performing unit tests and integration tests on the final code of each version in sequence, conducting automated testing and manual testing in parallel, and recording the test results; fixing the problems found in the tests, and performing regression testing on the fixed code until the tests pass.

[0020] The advantages of this application compared to existing technologies are as follows: This application provides a parallel development method for multiple versions of software products based on a large language model. It uses natural language processing algorithms to parse multiple version requirements and combines this with fine-tuning of the large language model to achieve intelligent generation, completion, and optimization of multiple version codes, significantly improving the accuracy of code generation and development efficiency, and reducing errors caused by manual intervention. It configures dual storage spaces for each design stage, enabling separate storage of initial and final design results for each version, avoiding untimely file updates due to rapid version changes, and ensuring effective continuity of results from each design stage. It detects and intelligently coordinates conflicts between multiple versions in real time, and combines incremental model fine-tuning after requirement changes to reduce development costs caused by requirement changes and version conflicts, ensuring that development progress is not affected. It adopts a combination of automated and manual testing to comprehensively cover software functions and scenarios, promptly identifying and fixing potential problems, and ensuring the quality of each version of the software product. Attached Figure Description

[0021] Figure 1 This is a flowchart of a method for parallel development of multiple versions of a software product based on a large language model, according to an embodiment of this application. Detailed Implementation

[0022] To make the content of this application easier to understand, the appendices in the embodiments of this application will be described below. Figure 1The technical solutions in the embodiments of this application will be clearly and completely described.

[0023] like Figure 1 As shown, a method for parallel development of multiple versions of software products based on a large language model includes the following steps:

[0024] Step 1: Multi-version requirement analysis and model building:

[0025] The system receives multiple software version development requests, which include information such as the functional descriptions, application scenarios, and performance indicators of each version. It uses natural language processing algorithms to perform in-depth analysis of each version's development request, identify and extract the key requirements, functional requirements, and constraints of each version, classify and prioritize the extracted requirements, clarify the core and secondary functions of each version, and finally generate a multi-version requirement model containing requirement information for all versions.

[0026] Step 2: Training the target large language model:

[0027] Based on the multi-version requirement model, we further extract the common requirements and differentiating features between versions. The differentiating features include functional differences, performance indicator differences, and interface requirement differences. We combine these features to construct a training dataset. Each data entry in the training dataset contains a natural statement, the code corresponding to the natural statement, and a version difference identifier used to identify the version to which it belongs.

[0028] At the same time, obtain the instruction template for instructing the generation of multiple versions of code. The instruction template includes task description, constraints, and input fields for filling in table creation statements, natural statements, code, and version difference identifiers. Fill each data entry in the training dataset into the instruction template according to the corresponding fields to form a training instruction set.

[0029] The initial large language model is fine-tuned using the training instruction set. By calculating the loss value between the predicted code output by the model and the target code in the training dataset, the model parameters are iteratively updated, and finally a target large language model adapted to parallel development of multiple versions is obtained. This target large language model can accurately identify the requirements of different versions and generate code that meets the requirements of the corresponding version.

[0030] Step 3: Multi-version parallel design and result storage:

[0031] The software design phase includes conceptual model design, business domain design, application service design, technical architecture design, development architecture design, data architecture design, application deployment design, and detailed application design. Each software design phase is configured with a first storage space and a second storage space. The first storage space is used to store the initial design results of each version in this phase, and the second storage space is used to store the final design results of each version in this phase.

[0032] Based on the multi-version requirement model and the target large language model, the initial design results of each design stage are generated in parallel for each version. The initial design results include system architecture sketches, module division schemes and core business logic descriptions, etc. After generation, they are stored in the first storage space of the corresponding design stage and associated with the corresponding version identifier.

[0033] Step 4: Design Result Optimization and Intelligent Code Processing:

[0034] For each version, the initial design results in the first storage space of each design stage are optimized and improved by the developers in combination with the requirements details of the target version, and detailed design content is added to form the final design results of that version in that design stage, and then stored in the second storage space of the corresponding stage.

[0035] After the final design is determined, it is input into the target large language model. Based on the functional descriptions and logical requirements in the design, the model generates an initial code framework. Subsequently, according to the specific functional details and performance indicators of the version, the target large language model automatically completes the missing parts of the code and corrects syntax and logical errors. At the same time, the model analyzes the code structure, logical implementation, error handling and performance bottlenecks, and outputs optimization suggestions. Developers then use these suggestions to optimize the code and obtain the final code for each version.

[0036] Step 5: Multi-version conflict detection and coordination:

[0037] During the parallel development of multiple versions, conflicts between different versions at the design and code levels are detected in real time. By comparing the data structure, code logic and interface definition of the design results of each version through the target large language model, conflict points such as data dependency conflicts, logical conflicts and interface incompatibilities are identified.

[0038] For the identified conflict points, based on the priority of each version, requirement constraints and project resources, the target large language model generates multiple conflict solutions. The development team combines the solution evaluation results and selects the optimal solution to coordinate and adjust the design results and code of the relevant versions to ensure that each version can independently meet the requirements and does not interfere with each other.

[0039] Step Six: Code Review and Integration Testing

[0040] The final code of each version is submitted to the version control system and enters the code review process. Reviewers evaluate the code's standardization, security, maintainability, and functional implementation, and make suggestions for modification. After the developers make the code modifications according to the suggestions, they submit it for review again. After multiple iterations, a final code version that meets the requirements is obtained.

[0041] Develop test plans based on the requirements models of each version, clarify test resource allocation, test strategies and test schedules, write automated test scripts covering key functions and boundary conditions, design manual test cases for complex interactions and user experience, execute unit tests and integration tests on the final code of each version in sequence, carry out automated tests and manual tests in parallel, and record test results in detail.

[0042] For the problems found in the test, the developers promptly fixed them and obtained the fixed code version. Regression tests were performed on the fixed code to verify whether the problem was completely resolved and whether no new problems were introduced. After the regression tests were passed, the integration verification of each version of the software product was completed, and the final software product was output.

[0043] If new version requirements are added or existing version requirements are changed during development, repeat the relevant processes from steps one to six, namely, analyze the new or changed requirements and update the multi-version requirement model, supplement the training dataset to incrementally fine-tune the target large language model, synchronously update the design results and code of the corresponding version, and re-execute the conflict detection and coordination and subsequent review and testing steps.

[0044] The above embodiments are only used to illustrate the technical solutions of the embodiments of this application, and are not intended to limit them. Although the embodiments of this application have been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features, without departing from the spirit and scope defined by the claims of this application.

Claims

1. A method for developing multiple versions of a software product in parallel based on a large language model, characterized in that, The method comprises the following steps: Step one, receiving a software multi-version development request, analyzing the development requirements of each version through a natural language processing algorithm, extracting the key demand points, functional requirements and constraint conditions of each version, and generating a multi-version demand model; Step two, based on the multi-version demand model, extract the common requirements and differentiated features of each version, build a training data set containing natural language, corresponding code and version difference identifier, and obtain an instruction template for indicating multi-version code generation; Fill the training data set into the instruction template to form a training instruction set, and use the training instruction set to fine-tune the initial large language model to obtain a target large language model suitable for multi-version parallel development; Step three, configure a first storage space and a second storage space for each software design stage, the first storage space is used to store the initial design results of each version, and the second storage space is used to store the final design results of each version, based on the multi-version demand model and the target large language model, the initial design results of each version are generated in parallel and stored in the corresponding first storage space; Step four, optimize and improve the initial design results of each version to form the final design results and store them in the corresponding second storage space, and use the target large language model to complete intelligent code generation, completion and optimization of each version during the period; Step five, real-time detection of conflicts between different versions in design results and code level, conflict coordination and solution based on preset rules and intelligent analysis of the target large language model; Step six, submit the final code of each version to the version control system, and after code review iteration, complete integration verification through automatic testing and manual testing, and output each version of the software product.

2. The method according to claim 1, wherein, In the step three, the software design stage includes conceptual model design, business domain design, application service design, technical architecture design, development architecture design, data architecture design, application deployment design and application detailed design, and the first storage space and the second storage space of each software design stage are independently associated with the version identifier.

3. The method according to claim 1, wherein, In the step two, the step of building the training data set comprises: determining the field theme word of the target field and the table building statement of the corresponding database based on the common requirements and differentiated features of each version; generating a statement data pair sample using the field theme word, the table building statement and the second instruction template, each statement data pair sample comprising a natural language, a corresponding code and a version difference identifier; and performing a deduplication process on the statement data pair sample to form a training data set.

4. The method according to claim 1, wherein, In the step two, the instruction template includes task description, constraint condition, table building statement input field, natural language input field, code input field and version identifier input field, wherein the code is at least one of SQL code and programming language code.

5. The method according to claim 1, wherein, In the step four, the step of using the target large language model to complete intelligent code generation, completion and optimization comprises: inputting the final design results of each version into the target large language model to generate an initial code framework; based on the functional details and performance requirements of the version, completing the code missing part and correcting the error code through the target large language model; analyzing the structure, logic implementation, error handling and performance bottleneck of the code, outputting optimization suggestions and completing code optimization.

6. The method according to claim 1, wherein, In the fifth step, the real-time detection of inter-version conflicts includes: comparing different versions of design outcome data structures, code logic and interface definitions by the target large language model; identifying conflict points with data dependency conflicts, logic conflicts and interface incompatibilities; generating conflict resolution solutions based on the priority and demand constraints of each version to coordinate and adjust the design outcomes and code of related versions.

7. The method according to claim 1, wherein, If new version requirements are added or existing version requirements are changed during development, parse the added or changed requirements and update the multi-version requirement model; based on the updated multi-version requirement model, supplement the training data set and incrementally fine-tune the target large language model; Synchronously update the design outcomes and code of the corresponding versions and re-execute the conflict detection and coordination steps.

8. The method according to claim 1, wherein, In the sixth step, the combination of automated testing and manual testing includes: developing a test plan based on the requirement model of each version, writing automated test scripts that cover key functions and boundary conditions, and designing manual test cases for complex interactions and user experience; sequentially executing unit testing and integration testing on the final code of each version, and conducting automated testing and manual testing in parallel while recording the test results; fixing the problems found during testing, and performing regression testing on the fixed code until the testing is passed.

Images