Automatic software development management method and system

Abstract

The invention relates to the technical field of development management, in particular to an automatic software development management method and system. The method comprises the following steps: acquiring a software development code, and extracting a nodal code annotation of the software development code; analyzing the code annotation to obtain an analysis result, and obtaining a task allocation condition of the developer; according to the task distribution condition, calling a project report record of a developer; and determining the actual development progress according to the analysis result and the project report record. By automatically extracting and analyzing the code annotations, project management personnel can more clearly understand the structure and the function of the codes, so that the development progress can be better tracked, the transparent development process is beneficial to communication among team members, and misunderstanding and conflicts are reduced. By analyzing code annotations and task allocation conditions, tasks can be allocated more reasonably, it is ensured that each developer can work in a specialized field, and the working efficiency is improved.

Description

Technical Field

[0001] The present application relates to the field of development management technology, and in particular to an automated software development management method and system. Background Art

[0002] In the current software development industry, the development of large software projects often requires multiple developers to work together. In order to achieve efficient division of labor and cooperation, the project is usually divided into multiple modules, which are responsible for different developers. This division of labor model can speed up development and improve work efficiency. However, this working model also brings a series of challenges.

[0003] There may be a lack of effective communication between developers, resulting in a lack of information exchange. Since each developer has different work content and progress, it is difficult to fully grasp the overall progress of the project. The project report of the developer may not be detailed or accurate, resulting in deviations in progress assessment. Different developers have different working methods and habits, and the management platform needs to be able to adapt to personalized working modes. Summary of the invention

[0004] The present application provides an automated software development management method and system to solve the above problems.

[0005] In a first aspect, the present application provides an automated software development management method, the method comprising:

[0006] Obtaining software development code and extracting node code annotations of the software development code;

[0007] Parsing the code comments to obtain parsing results and task allocation status of developers;

[0008] According to the task allocation, retrieve the project report record of the developer;

[0009] The actual development progress is determined based on the analysis results and the project report records.

[0010] Through this solution, by automatically extracting and parsing code comments, project managers can have a clearer understanding of the structure and function of the code, so as to better track the development progress. The transparent development process helps communication between team members and reduces misunderstandings and conflicts. By analyzing code comments and task allocation, tasks can be allocated more reasonably to ensure that each developer can work in his or her area of ​​expertise and improve work efficiency. Automated progress monitoring can help project managers to promptly discover deviations in project progress and take measures to adjust to ensure that the project is completed on time. Real-time progress reports can help the team understand the overall status of the project in a timely manner so as to make corresponding decisions. The parsing and evaluation of code comments can help identify potential problems in the code, such as excessive complexity or unclear logic, so as to timely refactor and optimize the code. By analyzing historical development records and code complexity, the skills and code quality of developers can be evaluated, providing a basis for team training and skill improvement. The automated process can reduce the daily workload of project managers, allowing them to have more time to focus on project strategy and team collaboration. By comparing the task status in code comments and project reporting records, developers can be ensured to complete tasks on time and reduce underreporting.

[0011] Optionally, extracting the node code annotations of the software development code includes:

[0012] Obtain and analyze the software development task list and obtain task analysis results;

[0013] Determine all development functions for software development based on the task analysis results;

[0014] For all development functions, extract the preset software development logic, and determine the code framework corresponding to each function based on the preset software development logic and all development functions;

[0015] Identify the software development code according to the code framework and determine the code module;

[0016] For the software development code, the function code corresponding to each code module is extracted and the node code comments in the function code are extracted.

[0017] Through this solution, the task list is mapped to the function list of software development, which can clarify the correspondence between the project and the actual work. Extracting the preset software development logic from the project's design documents helps to ensure that the code implementation is consistent with the design documents and improve the code quality. The code framework designed according to the preset logic and functional requirements can provide a clear structure, making the code more modular, readable and maintainable. Mapping the code modules with the development functions can help project managers more accurately evaluate the functional implementation of each module and reduce the deviation of progress evaluation. Extracting the node code comments in the functional code can provide detailed information about the code implementation, thereby accurately evaluating the actual completion of the code.

[0018] Optionally, determining the actual development progress according to the analysis result and the project report record includes:

[0019] Determine the semantic information of each node code annotation according to the parsing result;

[0020] Analyze the regional code of the context corresponding to each nodal code annotation, and determine the development function of the regional code according to the code analysis result;

[0021] matching the development function of the area code with the semantic information to determine whether the code annotation matches the development function of any area code;

[0022] If a match is determined, determining a representative position of each code annotation according to the development function of the area code and the semantic information;

[0023] Parsing the project report record, and matching the record parsing result with the development function of the area code to determine whether the project report record corresponds one-to-one with the development function of the area code;

[0024] If a one-to-one correspondence is determined, the actual development progress is determined based on the representative position, the development function, and the record analysis result.

[0025] Through this solution, by matching the node code comments with the development functions of the regional code, the actual implementation of the code can be evaluated more accurately, thereby improving the accuracy of the progress evaluation. Matching the project report records with the functional descriptions of the regional codes helps to ensure the detail and accuracy of the project reports and reduce the deviation of the progress evaluation. By analyzing the code comments and project reports, information sharing among team members can be promoted and problems caused by poor communication can be reduced. Ensure that all team members have a unified understanding of project goals, functions and progress, and improve team collaboration efficiency. By analyzing the code comments, the functions and design intent of the code can be determined, which helps to improve the quality and maintainability of the later code. By comparing the code comments and project reports, problems and deviations in the development process can be discovered in time and corrected in time.

[0026] Optionally, extracting the node code annotations in the function code includes:

[0027] Get all code comments contained in each function code;

[0028] interpreting all code comments contained in each function code, and classifying all code comments contained in each function code according to the interpretation result to obtain a classification result;

[0029] According to the classification result, a functional annotation is determined and used as the node code annotation.

[0030] Through this solution, by obtaining all code comments in each functional code and interpreting them using NLP technology, the functional description and current progress of each code snippet can be accurately identified, avoiding reliance on subjective reports from developers. Classify the comments and match the functions to ensure the consistency between the project report record and the actual development progress of the code, effectively reducing the deviation of progress assessment. Since different developers have different work progress and methods, automatic parsing and classification of comments can help team members understand each other's work content and reduce the phenomenon of information not being exchanged; this transparent progress management method can strengthen team collaboration and promote effective communication between developers. Different developers may have different working habits and reporting methods. In the process of project management, by analyzing code comments and function matching, progress reports can be automatically generated, reducing developers' reliance on reports and adapting to different personalized work modes. By automatically extracting node comments in functional codes, code documentation can be strengthened, helping developers understand and maintain code logic, and ensuring consistency and high standards of code quality.

[0031] Optionally, the determination of the preset software development logic includes:

[0032] According to all the development functions described, use the API interface to crawl the code and obtain the code crawling results;

[0033] Analyze the code crawling results and determine some basic development logics for each development function;

[0034] According to the task allocation, retrieve the historical development records of the corresponding developers;

[0035] Analyze the historical development records to determine the development capabilities of the corresponding developers;

[0036] According to the development capability, screening the several basic development logics to obtain the best development logic;

[0037] For all development functions, according to the task allocation, determine the best development logic for each development function, and obtain the best development logic for all development functions;

[0038] Use the optimal development logic for all development functions as the preset software development logic for the software development task list.

[0039] Through this solution, code crawling through the API interface can quickly obtain the basic logic of the code for each development function, which helps to understand the progress of the project. By retrieving the historical development records of the corresponding developers from the project management system, analyzing their development capabilities, and screening out the best basic development logic, the progress and development capabilities of each developer can be more accurately evaluated, so as to better grasp the overall progress of the project. The management platform can adapt to the working methods and habits of different developers, and can assign tasks according to the characteristics and habits of each developer to improve work efficiency. Based on all the development functions to be developed and the best basic development logic screened out, the best development logic for each development function is determined, which will help improve the quality and efficiency of software development.

[0040] Optionally, parsing the historical development records to determine the development capabilities of corresponding developers includes:

[0041] Parsing the historical development records to determine the historical development code of each developer;

[0042] Extracting existing comments in the historical development code;

[0043] Parsing the existing annotations to obtain annotation parsing results, and functionally disassembling the historical development code according to the annotation parsing results to obtain a number of historical functional codes;

[0044] Get the control flow graph of tasks corresponding to several historical function codes;

[0045] Parsing the control flow graph to determine the control flow node corresponding to each historical function code;

[0046] Analyze each historical function code and determine the number of control flow edges corresponding to each historical development code;

[0047] According to the control flow nodes and the control flow edge numbers, each historical function code is compared with the corresponding optimal development logic, and according to the comparison result, the complexity growth rate of each historical function code is determined;

[0048] Determine the development capabilities of the corresponding developers based on the complexity growth rate of each historical function code.

[0049] Through this solution, by analyzing the historical development records of each developer, we can fully understand each developer's task completion, code quality, optimization capabilities, etc., which is helpful to comprehensively evaluate the overall progress and quality of the project; through the analysis of control flow nodes, control flow edges and cyclomatic complexity, we can more accurately evaluate the development capabilities of developers and provide a basis for task allocation and personnel adjustments. According to the development capabilities and historical performance of each developer, tasks can be allocated more reasonably to improve team work efficiency. By comparing the best development logic, problems in the code can be discovered and optimized, and code quality and stability can be improved.

[0050] Optionally, after comparing each historical function code with the corresponding optimal development logic, it also includes:

[0051] Based on the comparison results, determine whether there is a logical difference between each function code and the corresponding optimal development logic;

[0052] If there is a logical difference, the difference code corresponding to the logical difference is parsed, and whether there is an additional development project is determined according to the difference parsing result;

[0053] Determining the complexity growth rate of the historical function code according to the comparison result includes:

[0054] Based on the comparison results and the additional development items, the complexity growth rate of the historical functional code is determined.

[0055] Through this solution, by comparing the functional code with the optimal development logic, the progress and status of the project can be fully understood, including the task completion status, code quality, optimization capabilities, etc. of each developer, which helps to fully understand the overall progress of the project. Through the analysis of control flow nodes, control flow edges and cyclomatic complexity, the development capabilities of developers can be more accurately evaluated to provide a basis for task allocation and personnel adjustments. If there are additional development projects, that is, there are obvious differences between the optimal development logic and the historical functional code, the complexity growth rate of the historical functional code can be determined based on the comparison results, additional development projects and the development capabilities of developers.

[0056] Optionally, the determining of the complexity growth rate of the historical function code according to the comparison result and the additional development project is implemented according to the following formula:

[0057]

[0058] Where k represents the total number of historical development codes; E represents the number of control flow edges corresponding to the i-th historical development code; N represents the control flow node corresponding to the i-th historical function code; M B,i represents the code cyclomatic complexity of the optimal development logic corresponding to the i-th historical development code; H represents the number of additional development projects; λ represents the weight coefficient of the additional development projects.

[0059] Through this solution, the quality and complexity of the code can be evaluated more accurately through indicators such as the number of control flow edges, control flow nodes, and code cyclomatic complexity. According to the complexity growth rate, tasks can be allocated and personnel can be adjusted more reasonably to improve the team's work efficiency and quality. According to the comparison results and additional development projects, the complexity growth rate of historical functional codes can be determined; and a more accurate evaluation of the real development capabilities of developers can be achieved.

[0060] Optionally, after matching the record parsing result with the development function of the area code to determine whether the project report record corresponds one-to-one with the development function of the area code, the method further includes:

[0061] If it is determined that the project report record does not correspond one-to-one to the development function of the area code, then an annotation keyword is determined based on the interpretation result;

[0062] Matching the annotation keywords with the project report records to determine the degree of matching;

[0063] Based on the matching degree, it is determined whether the developer makes a false report.

[0064] Through this solution, by parsing the project report records and matching them with the development functions of the corresponding regional codes, the overall progress of the project can be more comprehensively grasped, thereby better managing the project. Through matching calculation and judgment of false reports, the project progress can be more accurately evaluated, providing more accurate data support for project decision-making.

[0065] In a second aspect, the present application provides an automated software development management system, comprising:

[0066] An annotation extraction module, used to obtain software development code and extract node code annotations of the software development code;

[0067] An annotation parsing module, used to parse the code annotations, obtain parsing results and obtain the task allocation status of the developer;

[0068] A record retrieval module, used to retrieve the project report record of the developer according to the task allocation;

[0069] The progress analysis module is used to determine the actual development progress based on the analysis results and the project report records.

[0070] Optionally, when extracting the nodal code annotations of the software development code, the annotation extraction module is used to:

[0071] Obtain and analyze the software development task list and obtain task analysis results;

[0072] Determine all development functions for software development based on the task analysis results;

[0073] For all development functions, extract the preset software development logic, and determine the code framework corresponding to each function based on the preset software development logic and all development functions;

[0074] Identify the software development code according to the code framework and determine the code module;

[0075] For the software development code, the function code corresponding to each code module is extracted and the node code comments in the function code are extracted.

[0076] Optionally, when determining the actual development progress according to the analysis result and the project report record, the progress analysis module is used to:

[0077] Determine the semantic information of each node code annotation according to the parsing result;

[0078] Analyze the regional code of the context corresponding to each nodal code annotation, and determine the development function of the regional code according to the code analysis result;

[0079] matching the development function of the area code with the semantic information to determine whether the code annotation matches the development function of any area code;

[0080] If a match is determined, determining a representative position of each code annotation according to the development function of the area code and the semantic information;

[0081] Parsing the project report record, and matching the record parsing result with the development function of the area code to determine whether the project report record corresponds one-to-one with the development function of the area code;

[0082] If a one-to-one correspondence is determined, the actual development progress is determined based on the representative position, the development function, and the record analysis result.

[0083] Optionally, when extracting the nodal code annotations of the software development code, the annotation extraction module is used to:

[0084] Get all code comments contained in each function code;

[0085] interpreting all code comments contained in each function code, and classifying all code comments contained in each function code according to the interpretation result to obtain a classification result;

[0086] According to the classification result, a functional annotation is determined and used as the node code annotation.

[0087] Optionally, the automated software development management system further includes a logic setting module, which is used to:

[0088] According to all the development functions described, use the API interface to crawl the code and obtain the code crawling results;

[0089] Analyze the code crawling results and determine some basic development logics for each development function;

[0090] According to the task allocation, retrieve the historical development records of the corresponding developers;

[0091] Analyze the historical development records to determine the development capabilities of the corresponding developers;

[0092] According to the development capability, screening the several basic development logics to obtain the best development logic;

[0093] For all development functions, according to the task allocation, determine the best development logic for each development function, and obtain the best development logic for all development functions;

[0094] Use the optimal development logic for all development functions as the preset software development logic for the software development task list.

[0095] Optionally, when parsing the historical development records to determine the development capabilities of the corresponding developers, the logic setting module is used to:

[0096] Parsing the historical development records to determine the historical development code of each developer;

[0097] Extracting existing comments in the historical development code;

[0098] Parsing the existing annotations to obtain annotation parsing results, and functionally disassembling the historical development code according to the annotation parsing results to obtain a number of historical functional codes;

[0099] Get the control flow graph of tasks corresponding to several historical function codes;

[0100] Parsing the control flow graph to determine the control flow node corresponding to each historical function code;

[0101] Analyze each historical function code and determine the number of control flow edges corresponding to each historical development code;

[0102] According to the control flow nodes and the control flow edge numbers, each historical function code is compared with the corresponding optimal development logic, and according to the comparison result, the complexity growth rate of each historical function code is determined;

[0103] Determine the development capabilities of the corresponding developers based on the complexity growth rate of each historical function code.

[0104] Optionally, the automated software development management system further includes a growth calculation module, which is used to:

[0105] Based on the comparison results, determine whether there is a logical difference between each function code and the corresponding optimal development logic;

[0106] If there is a logical difference, the difference code corresponding to the logical difference is parsed, and whether there is an additional development project is determined according to the difference parsing result;

[0107] The complexity growth rate of the historical function code is determined according to the comparison result, for:

[0108] Based on the comparison results and the additional development items, the complexity growth rate of the historical functional code is determined.

[0109] Optionally, the growth calculation module determines the complexity growth rate of the historical function code according to the comparison result and the additional development project according to the following formula:

[0110]

[0111] Where k represents the total number of historical development codes; E represents the number of control flow edges corresponding to the i-th historical development code; N represents the control flow node corresponding to the i-th historical function code; M B,i represents the code cyclomatic complexity of the optimal development logic corresponding to the i-th historical development code; H represents the number of additional development projects; λ represents the weight coefficient of the additional development projects.

[0112] Optionally, the automated software development management system further includes a reporting and analysis module, which is used to:

[0113] If it is determined that the project report record does not correspond one-to-one to the development function of the area code, then an annotation keyword is determined based on the interpretation result;

[0114] Matching the annotation keywords with the project report records to determine the degree of matching;

[0115] Based on the matching degree, it is determined whether the developer makes a false report. BRIEF DESCRIPTION OF THE DRAWINGS

[0116] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, a brief introduction will be given below to the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative labor.

[0117] Figure 1 A schematic diagram of an application scenario provided for an embodiment of the present application;

[0118] Figure 2 A flowchart of an automated software development management method provided in one embodiment of the present application;

[0119] Figure 3 A schematic diagram of the structure of an automated software development management system provided in one embodiment of the present application. DETAILED DESCRIPTION

[0120] In order to make the purpose, technical scheme and advantages of the embodiments of the present application clearer, the technical scheme in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments are part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of this application.

[0121] In addition, the term "and / or" in this article is only a description of the association relationship of associated objects, indicating that there can be three relationships. For example, A and / or B can represent: A exists alone, A and B exist at the same time, and B exists alone. In addition, the character " / " in this article, unless otherwise specified, generally means that the associated objects before and after are in an "or" relationship.

[0122] The embodiments of the present application are further described in detail below in conjunction with the drawings in the specification.

[0123] There may be a lack of effective communication between developers, resulting in a lack of information exchange. Since each developer has different work content and progress, it is difficult to fully grasp the overall progress of the project. The project report of the developer may not be detailed or accurate, resulting in deviations in progress assessment. Different developers have different working methods and habits, and the management platform needs to be able to adapt to personalized working modes.

[0124] Based on this, the present application provides an automated software development management method, which extracts software development code and divides the project into multiple modules, allowing different developers to work simultaneously, thereby shortening the overall development cycle; each developer focuses on his own module, can more deeply understand and optimize the functions of that part, and improve development efficiency; by extracting and parsing the nodal comments of the code, the developers' thoughts, plans and problems can be shared, reducing the need for face-to-face communication, automatically extracting and parsing comments, and automatically retrieving reporting records, which can reduce the burden of daily work, and all relevant information is concentrated on one platform for unified management and supervision.

[0125] Figure 1 A schematic diagram of an application scenario provided for this application, when a large software project requires multiple developers to work together. Specifically, the method provided by this application is applied to any server, the server interacts with the code base, and the project is divided into multiple modules, which allows different developers to work at the same time, thereby shortening the overall development cycle; each developer focuses on his own module, can more deeply understand and optimize the functions of this part, and improve development efficiency; extract software development code from the code base, and by extracting and parsing the node annotations of the code, the developer's thinking, plans and problems can be shared, reducing the need for face-to-face communication, automatically extracting and parsing annotations, and automatically retrieving report records, which can reduce the burden of daily work, and all relevant information is concentrated on one platform for unified management and supervision.

[0126] For specific implementation methods, please refer to the following embodiments.

[0127] Figure 2This is a flowchart of an automated software development management method provided by an embodiment of the present application. The method of this embodiment can be applied to the server in the above scenario, and the server interacts with the project management system. Figure 2 As shown, the method includes:

[0128] S201. Obtain software development code and extract node code annotations of the software development code.

[0129] Node code comments can be comments in the code that describe key nodes or important steps in the code logic; they are usually used to explain complex parts, decision points or important functional modules in the code.

[0130] Specifically, in order to solve the problem that different developers have different working methods and habits, developers' project reports may not be detailed or accurate, resulting in deviations in progress assessment. Software development code is obtained from the project management system, and code analysis tools are used to analyze the code to identify and extract comments in the code.

[0131] S202: Parse the code comments to obtain parsing results and acquire the task allocation status of the developer.

[0132] Task allocation can be a situation where, during the software development process, the project is broken down into multiple subtasks and these subtasks are assigned to different developers.

[0133] Specifically, use natural language processing (NLP) technology to parse the natural language in the comments and extract task information; identify keywords, phrases or patterns from the comments to determine the task type, priority, status, etc.; if the project uses a task management tool, obtain task assignment information through API or integrated plug-in.

[0134] S203. According to the task allocation situation, retrieve the project report record of the developer.

[0135] Project report records can be reports submitted regularly by developers during the software development process to update the project status, progress and problems encountered; they usually include completed work, remaining tasks, technical difficulties encountered and next steps.

[0136] Specifically, according to the task allocation, use the API of the project management tool, database query or log analysis tool to extract each developer's report records related to the task allocation, such as completion status, problems encountered, timeline, etc.;

[0137] S204. Determine the actual development progress based on the analysis results and project report records.

[0138] The actual development progress can be the actual amount of work completed by developers based on the project plan and task allocation.

[0139] Specifically, compare the task status extracted from the code comments with the status in the project report records to check whether there are any missing reports, so as to determine the accuracy of the actual development progress.

[0140] Through this solution, by automatically extracting and parsing code comments, project managers can have a clearer understanding of the structure and function of the code, so as to better track the development progress. The transparent development process helps communication between team members and reduces misunderstandings and conflicts. By analyzing code comments and task allocation, tasks can be allocated more reasonably to ensure that each developer can work in his or her area of ​​expertise and improve work efficiency. Automated progress monitoring can help project managers to promptly discover deviations in project progress and take measures to adjust to ensure that the project is completed on time. Real-time progress reports can help the team understand the overall status of the project in a timely manner so as to make corresponding decisions. The parsing and evaluation of code comments can help identify potential problems in the code, such as excessive complexity or unclear logic, so as to timely refactor and optimize the code. By analyzing historical development records and code complexity, the skills and code quality of developers can be evaluated, providing a basis for team training and skill improvement. The automated process can reduce the daily workload of project managers, allowing them to have more time to focus on project strategy and team collaboration. By comparing the task status in code comments and project reporting records, developers can be ensured to complete tasks on time and reduce underreporting.

[0141] In some embodiments, a software development task list is obtained and analyzed to obtain task analysis results; based on the task analysis results, all development functions of the software development are determined; for all development functions, the preset software development logic is extracted, and based on the preset software development logic and all development functions, the code framework corresponding to each function is determined; the software development code is identified based on the code framework, and the code module is determined; for the software development code, the function code corresponding to each code module is extracted and the node code comments in the function code are extracted.

[0142] The preset software development logic can be the overall ideas and methods of software implementation that are pre-planned based on project requirements and technical design documents before software development begins. It generally includes software function design, data flow design, interface design, algorithm design, etc.

[0143] A code framework can be a code structure built to implement preset software development logic, which usually includes a series of classes, interfaces, functions and modules, as well as the relationships between them.

[0144] Code modules are units of independent functionality in code. They can be a single file, a group of related files, or a separate library.

[0145] Specifically, use the API of the task management tool (such as Jira, Trello) to obtain the task list; parse the obtained task list into a structured data format, classify the tasks according to the task type (such as new features, fixes, improvements, etc.), identify the dependencies between tasks, determine the execution order of tasks, and map the task list to the function list of software development; based on the task analysis results, define the detailed requirements of each development function, and extract the preset software development logic from the design documents in the project management library; according to the preset logic and functional requirements, design the structure and modules of the code, use the code analysis tool to analyze the code base, identify the code modules, map the code modules to the development functions, and determine the functions of each module; parse each code module, extract the functional code, identify and extract the nodal code comments in the functional code, use natural language processing technology to analyze the comments, and extract the nodal code comments.

[0146] Through this solution, the task list is mapped to the function list of software development, which can clarify the correspondence between the project and the actual work. Extracting the preset software development logic from the project's design documents helps to ensure that the code implementation is consistent with the design documents and improve the code quality. The code framework designed according to the preset logic and functional requirements can provide a clear structure, making the code more modular, readable and maintainable. Mapping the code modules with the development functions can help project managers more accurately evaluate the functional implementation of each module and reduce the deviation of progress evaluation. Extracting the node code comments in the functional code can provide detailed information about the code implementation, thereby accurately evaluating the actual completion of the code.

[0147] In some embodiments, the semantic information of each nodal code annotation is determined based on the parsing results; the regional code of the context corresponding to each nodal code annotation is analyzed, and the development function of the regional code is determined based on the code analysis results; the development function of the regional code is matched with the semantic information to determine whether the code annotation matches the development function of any regional code; if a match is determined, the representative position of each code annotation is determined based on the development function and semantic information of the regional code; the project report record is parsed, and the record parsing results are matched with the development function of the regional code to determine whether the project report record corresponds one-to-one with the development function of the regional code; if a one-to-one correspondence is determined, the actual development progress is determined based on the representative position, development function, and record parsing results.

[0148] A region code can be a specific code fragment in the code base of the project management system. It may be a function, a method, a class definition or a code block.

[0149] The representative location can be the location information of a specific code snippet or comment in the code structure in the code base of the project management system.

[0150] Specifically, when analyzing the actual development progress through comments, there are inaccurate comments: for example, the function described in the comment does not match the actual implementation, or the function and behavior of the code are not accurately described, which will lead to analysis errors; incomplete comments: for example, the comment does not cover all the content that needs to be explained, such as input and output parameters, exception handling, etc., which may cause the analysis to miss some key information; there are general ideas for undeveloped functions, and developers follow the advance annotations and write them in the form of modules; such comments may have empty code content. If only comment analysis is performed, it will cause a false alarm of early progress. Therefore, natural language processing (NLP) technology is used to parse node code comments, extract semantic information, analyze keywords, phrases and context in the comments, so as to determine the function or logic described by the comments; code analysis tools are used to analyze the area code where the comments are located, extract the functional description of the code, and identify the functions implemented by the area code based on the structure and logic of the code; the semantic information of the node code comments is matched with the functional description of the area code to determine whether the code comments accurately describe the functions of the area code; based on the matching results, the representative position of the code comments in the project is determined, and the location of the code comments is marked in the project management tool or code library for easy tracking and reference; the project report records are parsed to extract the development functions, progress and problems reported by developers, the report records are parsed into structured data, the development functions in the report records are matched with the functional description of the area code, and the development progress of the area code is evaluated based on the progress information of the report records, and the actual development progress is determined based on the location of the code comments, the development functions and the parsed results of the report records.

[0151] Through this solution, by matching the node code comments with the development functions of the regional code, the actual implementation of the code can be evaluated more accurately, thereby improving the accuracy of the progress evaluation. Matching the project report records with the functional descriptions of the regional codes helps to ensure the detail and accuracy of the project reports and reduce the deviation of the progress evaluation. By analyzing the code comments and project reports, information sharing among team members can be promoted and problems caused by poor communication can be reduced. Ensure that all team members have a unified understanding of project goals, functions and progress, and improve team collaboration efficiency. By analyzing the code comments, the functions and design intent of the code can be determined, which helps to improve the quality and maintainability of the later code. By comparing the code comments and project reports, problems and deviations in the development process can be discovered in time and corrected in time.

[0152] In some embodiments, all code comments contained in each function code are obtained; all code comments contained in each function code are interpreted, and based on the interpretation results, all code comments contained in each function code are classified to obtain classification results; based on the classification results, the function annotations are determined and used as nodal code annotations.

[0153] Specifically, if code comments are used directly, the comments will be unclear due to the different habits and self-logic of developers: if the comments are too complex or difficult to understand, the analysis may misunderstand or miss the key information, resulting in analysis errors. Use code scanning tools or write scripts to traverse all files in the functional code base; identify and extract all code comments contained in each functional code, including single-line comments, multi-line comments, and document strings. Use natural language processing (NLP) technology to interpret the code comments in each functional code and extract the key information and intentions in the comments. Analyze the keywords, phrases, and context in the comments to determine the function or logic described by the comments. According to the project requirements and development specifications, define the classification standards for code comments, such as "function description", "design ideas", "to-do items", "known issues", etc.; classify the code comments in each functional code according to the interpretation results to obtain the classification results; according to the classification results, determine which comments are node code comments.

[0154] Through this solution, by obtaining all code comments in each functional code and interpreting them using NLP technology, the functional description and current progress of each code snippet can be accurately identified, avoiding reliance on subjective reports from developers. Classify the comments and match the functions to ensure the consistency between the project report record and the actual development progress of the code, effectively reducing the deviation of progress assessment. Since different developers have different work progress and methods, automatic parsing and classification of comments can help team members understand each other's work content and reduce the phenomenon of information not being exchanged; this transparent progress management method can strengthen team collaboration and promote effective communication between developers. Different developers may have different working habits and reporting methods. In the process of project management, by analyzing code comments and function matching, progress reports can be automatically generated, reducing developers' reliance on reports and adapting to different personalized work modes. By automatically extracting node comments in functional codes, code documentation can be strengthened, helping developers understand and maintain code logic, and ensuring consistency and high standards of code quality.

[0155] In some embodiments, based on all development functions, code crawling is performed using an API interface to obtain code crawling results; the code crawling results are parsed to determine several basic development logics for each development function; based on the task allocation situation, the historical development records of the corresponding developers are retrieved; the historical development records are parsed to determine the development capabilities of the corresponding developers; based on the development capabilities, several basic development logics are screened to obtain the best development logic; for all development functions, based on the task allocation situation, the best development logic for each development function is determined to obtain the best development logic for all development functions; the best development logic for all development functions is used as the preset software development logic for the software development task list.

[0156] The basic development logic may be the basic development steps for developing functions during the software development process.

[0157] The best development logic can be achieved through a process of continuous optimization and adjustment based on the basic development logic, according to factors such as problems encountered in the actual development process, feedback, and experience.

[0158] Specifically, the code is crawled through the API interface to obtain the basic logic of the code for each development function; according to the task allocation, the historical development records of the corresponding developers are retrieved from the project management system. The historical development records of the corresponding developers are analyzed and parsed to determine their development capabilities. The best basic development logic is screened out based on the development capabilities of each developer and their previous project experience. The best development logic for each development function is determined based on all the development functions to be developed and the best basic development logic screened out. The best development logic of all the development functions to be developed is integrated together to form a set of software development logic for a preset software development task list. On this basis, the progress of the report can be checked and the abnormal progress can be paid attention to. For example, for a module code, the code volume of the same type is matched according to the best development logic (generally how many lines and how many words), and the functional code volume in this development is estimated according to the developer's developed capabilities. Through the proofreading between the code volumes, if the code volume gap is not within the error range, it will be paid attention to. In this way, developers with excellent code optimization capabilities and progress misreporting can be discovered.

[0159] Through this solution, code crawling through the API interface can quickly obtain the basic logic of the code for each development function, which helps to understand the progress of the project. By retrieving the historical development records of the corresponding developers from the project management system, analyzing their development capabilities, and screening out the best basic development logic, the progress and development capabilities of each developer can be more accurately evaluated, so as to better grasp the overall progress of the project. The management platform can adapt to the working methods and habits of different developers, and can assign tasks according to the characteristics and habits of each developer to improve work efficiency. Based on all the development functions to be developed and the best basic development logic screened out, the best development logic for each development function is determined, which will help improve the quality and efficiency of software development.

[0160] In some embodiments, historical development records are parsed to determine the historical development code of each developer; existing comments in the historical development code are extracted; the existing comments are parsed to obtain comment parsing results, and based on the comment parsing results, the historical development code is functionally decomposed to obtain a number of historical function codes; control flow graphs of tasks corresponding to the several historical function codes are obtained; the control flow graphs are parsed to determine the control flow nodes corresponding to each historical function code; each historical function code is parsed to determine the number of control flow edges corresponding to each historical development code; based on the control flow nodes and the number of control flow edges, each historical function code is compared with the corresponding optimal development logic, and based on the comparison results, the complexity growth rate of each historical function code is determined; based on the complexity growth rate of each historical function code, the development capability of the corresponding developer is determined.

[0161] Control flow nodes can be key points in the program control process, that is, turning points in the program execution process, such as conditional judgment, loops, function calls, etc.

[0162] The number of control flow edges may be the number of edges in a control flow graph that represent the flow of program control.

[0163] The complexity growth rate can be the growth of the complexity of historical functional codes relative to the basic development logic, which can be used to evaluate the development capabilities of developers and project progress.

[0164] Specifically, parse the historical development records of all developers retrieved from the project management system, extract the historical development code, extract the existing comments from the historical development code, and according to the comment parsing results, functionally decompose the historical development code to obtain several historical function codes. For each historical function code, obtain the control flow graph of its corresponding task. The control flow graph can intuitively represent the control flow of the program. The control flow graph is parsed to determine the control flow node corresponding to each historical function code. Parse each historical function code to determine the corresponding number of control flow edges. According to the control flow nodes and the number of control flow edges, compare each historical function code with the corresponding optimal development logic to determine the complexity growth rate of each historical function code. According to the complexity growth rate of each historical function code, determine the development capability of the corresponding developer. In this implementation, cyclomatic complexity is constructed by the number of control flow nodes and control flow edges, and the developer's ability is then evaluated by means of cyclomatic complexity. If the cyclomatic complexity growth rate of the code written by the developer is smaller than that of the optimal development logic, the developer's ability is stronger. If the growth rate is negative, it means that the developer has excellent optimization ability, that is, the cyclomatic complexity of the current function is smaller than the cyclomatic complexity corresponding to the optimal development logic.

[0165] Through this solution, by analyzing the historical development records of each developer, we can fully understand each developer's task completion, code quality, optimization capabilities, etc., which is helpful to comprehensively evaluate the overall progress and quality of the project; through the analysis of control flow nodes, control flow edges and cyclomatic complexity, we can more accurately evaluate the development capabilities of developers and provide a basis for task allocation and personnel adjustments. According to the development capabilities and historical performance of each developer, tasks can be allocated more reasonably to improve team work efficiency. By comparing the best development logic, problems in the code can be discovered and optimized, and code quality and stability can be improved.

[0166] In some embodiments, based on the comparison results, it is determined whether there are logical differences in each function code with the corresponding optimal development logic; if there are logical differences, the difference code corresponding to the logical difference is parsed, and based on the difference parsing results, it is determined whether there are additional development projects; based on the comparison results, the complexity growth rate of the historical function code is determined, including: determining the complexity growth rate of the historical function code based on the comparison results and the additional development projects.

[0167] Logic differences may be differences that exist between best-developed logic and historical functional code.

[0168] Additional development projects may be tasks or functions that are found to require additional development based on comparison results and historical development records.

[0169] Specifically, by comparing each function code with the corresponding optimal development logic, it can be determined whether there are logical differences. If there are differences, the existing logical differences, i.e., the difference codes, are analyzed based on the comparison results. These differences may be caused by the personal habits and different understandings of the developers, or they may be due to the optimization or negative optimization of the code by the developers' development capabilities, or the need for additional development of functions in the development project so that other functional modules can call them, or to facilitate the interface functions for later expansion. If there are additional development projects, that is, there are obvious differences between the optimal development logic and the historical function code, the complexity growth rate of the historical function code can be determined based on the comparison results and the additional development projects. Compared with the previous implementation, this implementation pays more attention to the determination of additional development projects by developers in the process of comparing cyclomatic complexity, and the existence of additional development projects will inevitably increase the cyclomatic complexity, thereby affecting the calculation of the complexity growth rate.

[0170] Through this solution, by comparing the functional code with the optimal development logic, the progress and status of the project can be fully understood, including the task completion status, code quality, optimization capabilities, etc. of each developer, which helps to fully understand the overall progress of the project. Through the analysis of control flow nodes, control flow edges and cyclomatic complexity, the development capabilities of developers can be more accurately evaluated to provide a basis for task allocation and personnel adjustments. If there are additional development projects, that is, there are obvious differences between the optimal development logic and the historical functional code, the complexity growth rate of the historical functional code can be determined based on the comparison results, additional development projects and the development capabilities of developers.

[0171] In some embodiments, the complexity growth rate of the historical function code is determined based on the comparison results and the additional development project, and is implemented according to the following formula (1):

[0172]

[0173] Where k represents the total number of historical development codes; E represents the number of control flow edges corresponding to the i-th historical development code; N represents the control flow node corresponding to the i-th historical function code; M B,i represents the code cyclomatic complexity of the optimal development logic corresponding to the i-th historical development code; H represents the number of additional development projects; λ represents the weight coefficient of the additional development projects.

[0174] Specifically, the complexity growth rate is determined by comparing the number of control flow edges, control flow nodes, code cyclomatic complexity of the optimal development logic and the number of additional development projects of the historical development code. When determining the complexity growth rate, it is necessary to subtract the code cyclomatic complexity of the corresponding optimal development logic of the historical development code from the cyclomatic complexity of all historical development codes to determine the increase in cyclomatic complexity of each historical functional code, and then add up the number of all historical development codes, subtract the number of additional development projects multiplied by λ for conversion, thereby subtracting the difference in complexity increase caused by additional development projects, and then divide it by the sum of the code cyclomatic complexities of the corresponding optimal development logic of all historical development codes, and then multiply by 100%.

[0175] Through this solution, the quality and complexity of the code can be evaluated more accurately through indicators such as the number of control flow edges, control flow nodes, and code cyclomatic complexity. According to the complexity growth rate, tasks can be allocated and personnel can be adjusted more reasonably to improve the team's work efficiency and quality. According to the comparison results and additional development projects, the complexity growth rate of historical functional codes can be determined; and a more accurate evaluation of the real development capabilities of developers can be achieved.

[0176] In some embodiments, if it is determined that the project report record does not correspond one-to-one to the development function of the regional code, the annotation keywords are determined based on the interpretation results; the annotation keywords are matched with the project report record to determine the matching degree; based on the matching degree, it is determined whether the developer has made a false report.

[0177] Specifically, in order to prevent programmers from taking advantage of the progress reporting mechanism after understanding it, the project report records are parsed to extract key information, such as task completion status, problem feedback, etc.; based on the parsed information, the project report records are matched with the development functions of the regional code. This may require the establishment of a mapping relationship, such as the correspondence between functional modules and regional codes; based on the matching results, the matching degree between the project report records and the development functions of the regional code is determined by calculating matching accuracy, coverage and other indicators, and based on the matching degree, it is determined whether the developer has made a false report. If the matching degree is very low, or there is no match at all, it may mean that the developer has not reported the project progress truthfully or there is a problem.

[0178] Through this solution, by parsing the project report records and matching them with the development functions of the corresponding regional codes, the overall progress of the project can be more comprehensively grasped, thereby better managing the project. Through matching calculation and judgment of false reports, the project progress can be more accurately evaluated, providing more accurate data support for project decision-making.

[0179] Figure 3 A schematic diagram of the structure of an automated software development management system provided in one embodiment of the present application is shown in FIG. Figure 3 As shown, the automated software development management system 300 of this embodiment includes: an annotation extraction module 301 , an annotation parsing module 302 , a record retrieval module 303 , and a progress analysis module 304 .

[0180] Annotation extraction module 301, used to obtain software development code and extract node code annotations of the software development code;

[0181] Annotation parsing module 302, used to parse the code annotations, obtain parsing results and obtain the task allocation of developers;

[0182] A record retrieval module 303 is used to retrieve the project report record of the developer according to the task allocation situation;

[0183] The progress analysis module 304 is used to determine the actual development progress according to the analysis results and the project report records.

[0184] Optionally, when extracting the nodal code annotations of the software development code, the annotation extraction module 301 is used to:

[0185] Obtain and analyze the software development task list and obtain task analysis results;

[0186] Determine all development functions for software development based on the task analysis results;

[0187] For all development functions, extract the preset software development logic, and determine the code framework corresponding to each function based on the preset software development logic and all development functions;

[0188] Identify the software development code according to the code framework and determine the code module;

[0189] For the software development code, the function code corresponding to each code module is extracted and the node code comments in the function code are extracted.

[0190] Optionally, when determining the actual development progress according to the analysis result and the project report record, the progress analysis module 304 is used to:

[0191] Determine the semantic information of each node code annotation according to the parsing result;

[0192] Analyze the regional code of the context corresponding to each nodal code annotation, and determine the development function of the regional code according to the code analysis result;

[0193] matching the development function of the area code with the semantic information to determine whether the code annotation matches the development function of any area code;

[0194] If a match is determined, determining a representative position of each code annotation according to the development function of the area code and the semantic information;

[0195] Parsing the project report record, and matching the record parsing result with the development function of the area code to determine whether the project report record corresponds one-to-one with the development function of the area code;

[0196] If a one-to-one correspondence is determined, the actual development progress is determined based on the representative position, the development function, and the record analysis result.

[0197] Optionally, when extracting the nodal code annotations of the software development code, the annotation extraction module 301 is used to:

[0198] Get all code comments contained in each function code;

[0199] interpreting all code comments contained in each function code, and classifying all code comments contained in each function code according to the interpretation result to obtain a classification result;

[0200] According to the classification result, a functional annotation is determined and used as the node code annotation.

[0201] Optionally, the automated software development management system 300 further includes a logic setting module 305, which is used to:

[0202] According to all the development functions described, use the API interface to crawl the code and obtain the code crawling results;

[0203] Analyze the code crawling results and determine some basic development logics for each development function;

[0204] According to the task allocation, retrieve the historical development records of the corresponding developers;

[0205] Analyze the historical development records to determine the development capabilities of the corresponding developers;

[0206] According to the development capability, screening the several basic development logics to obtain the best development logic;

[0207] For all development functions, according to the task allocation, determine the best development logic for each development function, and obtain the best development logic for all development functions;

[0208] Use the optimal development logic for all development functions as the preset software development logic for the software development task list.

[0209] Optionally, when parsing the historical development records to determine the development capabilities of the corresponding developers, the logic setting module 305 is used to:

[0210] Parsing the historical development records to determine the historical development code of each developer;

[0211] Extracting existing comments in the historical development code;

[0212] Parsing the existing annotations to obtain annotation parsing results, and functionally disassembling the historical development code according to the annotation parsing results to obtain a number of historical functional codes;

[0213] Get the control flow graph of tasks corresponding to several historical function codes;

[0214] Parsing the control flow graph to determine the control flow node corresponding to each historical function code;

[0215] Analyze each historical function code and determine the number of control flow edges corresponding to each historical development code;

[0216] According to the control flow nodes and the control flow edge numbers, each historical function code is compared with the corresponding optimal development logic, and according to the comparison result, the complexity growth rate of each historical function code is determined;

[0217] Determine the development capabilities of the corresponding developers based on the complexity growth rate of each historical function code.

[0218] Optionally, the automated software development management system 300 further includes a growth calculation module 306, which is used to:

[0219] Based on the comparison results, determine whether there is a logical difference between each function code and the corresponding optimal development logic;

[0220] If there is a logical difference, the difference code corresponding to the logical difference is parsed, and whether there is an additional development project is determined according to the difference parsing result;

[0221] The complexity growth rate of the historical function code is determined according to the comparison result, for:

[0222] Based on the comparison results and the additional development items, the complexity growth rate of the historical functional code is determined.

[0223] Optionally, the growth calculation module 306 determines the complexity growth rate of the historical function code according to the comparison result and the additional development project according to the following formula:

[0224]

[0225] Where k represents the total number of historical development codes; E represents the number of control flow edges corresponding to the i-th historical development code; N represents the control flow node corresponding to the i-th historical function code; M B,i represents the code cyclomatic complexity of the optimal development logic corresponding to the i-th historical development code; H represents the number of additional development projects; λ represents the weight coefficient of the additional development projects.

[0226] Optionally, the automated software development management system 300 further includes a reporting and analysis module 307, which is used to:

[0227] If it is determined that the project report record does not correspond one-to-one to the development function of the area code, then an annotation keyword is determined based on the interpretation result;

[0228] Matching the annotation keywords with the project report records to determine the degree of matching;

[0229] Based on the matching degree, it is determined whether the developer makes a false report.

[0230] The system of this embodiment can be used to execute the method of any of the above embodiments. The implementation principles and technical effects are similar and will not be described in detail here.

Claims

1. An automated software development management method, characterized in that: include: Obtaining software development code and extracting node code annotations of the software development code; Parsing the code comments to obtain parsing results and task allocation status of developers; According to the task allocation, retrieve the project report record of the developer; Determine the actual development progress according to the analysis results and the project report records; The step of extracting the nodal code annotations of the software development code comprises: Obtain and analyze the software development task list and obtain task analysis results; Determine all development functions for software development based on the task analysis results; For all development functions, extract the preset software development logic, and determine the code framework corresponding to each function based on the preset software development logic and all development functions; Identify the software development code according to the code framework and determine the code module; For the software development code, the function code corresponding to each code module is extracted and the node code comments in the function code are extracted.

2. The method according to claim 1, characterized in that Determining the actual development progress according to the analysis results and the project report records includes: Determine the semantic information of each node code annotation according to the parsing result; Analyze the regional code of the context corresponding to each nodal code annotation, and determine the development function of the regional code according to the code analysis result; matching the development function of the area code with the semantic information to determine whether the code annotation matches the development function of any area code; If a match is determined, determining a representative position of each code annotation according to the development function of the area code and the semantic information; Parsing the project report record, and matching the record parsing result with the development function of the area code to determine whether the project report record corresponds one-to-one with the development function of the area code; If a one-to-one correspondence is determined, the actual development progress is determined based on the representative position, the development function, and the record analysis result.

3. The method according to claim 1, characterized in that The step of extracting the node code annotations in the function code comprises: Get all code comments contained in each function code; interpreting all code comments contained in each function code, and classifying all code comments contained in each function code according to the interpretation result to obtain a classification result; According to the classification result, a functional annotation is determined and used as the node code annotation.

4. The method according to claim 1, characterized in that The determination of the preset software development logic includes: According to all the development functions described, use the API interface to crawl the code and obtain the code crawling results; Analyze the code crawling results and determine some basic development logics for each development function; According to the task allocation, retrieve the historical development records of the corresponding developers; Analyze the historical development records to determine the development capabilities of the corresponding developers; According to the development capability, screening the several basic development logics to obtain the best development logic; For all development functions, according to the task allocation, determine the best development logic for each development function, and obtain the best development logic for all development functions; Use the optimal development logic for all development functions as the preset software development logic for the software development task list.

5. The method according to claim 4, characterized in that The analyzing the historical development records to determine the development capabilities of the corresponding developers includes: Parsing the historical development records to determine the historical development code of each developer; Extracting existing comments in the historical development code; Parsing the existing annotations to obtain annotation parsing results, and functionally disassembling the historical development code according to the annotation parsing results to obtain a number of historical functional codes; Get the control flow graph of tasks corresponding to several historical function codes; Parsing the control flow graph to determine the control flow node corresponding to each historical function code; Analyze each historical function code and determine the number of control flow edges corresponding to each historical development code; According to the control flow nodes and the control flow edge numbers, each historical function code is compared with the corresponding optimal development logic, and according to the comparison result, the complexity growth rate of each historical function code is determined; Determine the development capabilities of the corresponding developers based on the complexity growth rate of each historical function code.

6. The method according to claim 5, characterized in that After comparing each historical function code with the corresponding optimal development logic, it also includes: Based on the comparison results, determine whether there is a logical difference between each function code and the corresponding optimal development logic; If there is a logical difference, the difference code corresponding to the logical difference is parsed, and whether there is an additional development project is determined according to the difference parsing result; Determining the complexity growth rate of the historical function code according to the comparison result includes: Based on the comparison results and the additional development items, the complexity growth rate of the historical functional code is determined.

7. The method according to claim 6, characterized in that The complexity growth rate of the historical function code is determined based on the comparison results and the additional development project, and is implemented according to the following formula: Where k represents the total number of historical development codes; E represents the number of control flow edges corresponding to the i-th historical development code; N represents the control flow node corresponding to the i-th historical function code; M B,i represents the code cyclomatic complexity of the optimal development logic corresponding to the i-th historical development code; H represents the number of additional development projects; λ represents the weight coefficient of the additional development projects.

8. The method according to claim 2, characterized in that: After matching the record parsing result with the development function of the area code to determine whether the project report record corresponds to the development function of the area code, the method further includes: If it is determined that the project report record does not correspond one-to-one to the development function of the area code, then an annotation keyword is determined based on the interpretation result; Matching the annotation keywords with the project report records to determine the degree of matching; Based on the matching degree, it is determined whether the developer makes a false report.

9. An automated software development management system, characterized in that: The method as claimed in any one of claims 1 to 8 comprises: An annotation extraction module, used to obtain software development code and extract node code annotations of the software development code; An annotation parsing module, used to parse the code annotations, obtain parsing results and obtain the task allocation status of the developer; A record retrieval module, used to retrieve the project report record of the developer according to the task allocation; The progress analysis module is used to determine the actual development progress based on the analysis results and the project report records.

Images