A method for measuring R&D effectiveness based on agile software engineering
Patent Information
- Application Number
- CN202611101071.X
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-07-23
- Publication Date
- 2026-11-17
AI Technical Summary
Existing agile development performance measurement methods suffer from several problems: teams prioritize story completion rates over quality and scope, ignore differences in story complexity, have a single efficiency dimension, struggle to accurately assess team performance, and suffer from inadequate root cause analysis due to broad task categorization.
By clearly defining the type and deliverables of each task, establishing the relationship between task type, deliverables, and time, and using project management tools and automated data processing pipelines, a task type and throughput table is generated for dynamic analysis to identify and optimize performance issues.
It enables performance evaluation to move from vague perception to precise quantification, optimizes decision-making from experience-driven to data-driven, provides a feasible and sustainable path to improve performance, helps teams identify and improve bottlenecks, and enhances team performance.
Smart Images

Figure CN123114422A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the technical field of process systems for software engineering using agile development, and more particularly to a method for measuring R&D effectiveness based on agile software engineering. Background Technology
[0002] Agile software engineering is a lightweight development methodology that focuses on evolving user needs and employs an iterative, incremental approach to software development. Its core idea is to rapidly adapt to change by releasing small, frequent updates, allowing customers to see the product early and provide feedback, thereby reducing development risks and increasing customer satisfaction. Key methodologies include Scrum (an iterative, incremental software development process) and SAFe (a large-scale agile framework).
[0003] With the widespread adoption of Agile development and DevOps methodologies in the software industry, enterprises need to quantify and evaluate the effectiveness of rapid iteration and continuous delivery. Static metrics (such as project completion rate) in traditional project management models (like the waterfall model) are no longer adequate for dynamic changes in requirements and parallel collaboration scenarios. Agile teams need to use metrics (such as requirement delivery cycle time and sprint throughput) to achieve transparent management and continuous improvement, thereby addressing the challenges of a VUCA (Volatility, Uncertainty, Complexity, Ambiguity) environment.
[0004] The measurement of R&D effectiveness needs to cover the entire chain from technology execution to business value, including the basic capability layer focusing on the effectiveness of R&D infrastructure and toolchain, the product delivery layer focusing on the efficiency of demand flow, using indicators such as demand throughput and lead time, and the business value layer measuring the realization of end-user value, such as demand value conversion rate and customer satisfaction.
[0005] The complexity of agile development necessitates end-to-end data integration, including automated data collection through DevOps toolchain APIs or plugins to avoid errors from manual data entry; multi-source data fusion integrating code repositories, task management systems, testing tools, and operational monitoring data to build a unified data source; and real-time visualization using dashboards to display burn-down charts, flow efficiency trends, etc., supporting dynamic decision-making. Agile development metrics should be scientifically designed to avoid traditional measurement pitfalls, including prioritizing outcome metrics (such as requirement delivery cycle time, production defect rate) over process metrics; and dynamically balancing throughput ("more") with delivery speed ("fast") and quality ("good") to create a balance. The technical background of agile development performance measurement integrates layered theory, end-to-end data integration, scientific metric design, and a systematic improvement framework, aiming to drive continuous optimization through quantitative analysis. Future trends will place greater emphasis on AI-assisted intelligent diagnostics (such as automatic bottleneck identification) and ecosystem platform construction (such as open APIs integrating third-party tools).
[0006] The existing solutions mainly include the following key indicators and measurement methods: Agile Process Story Completion Rate: This metric measures a team's ability to complete stories as planned during agile development by calculating the ratio of completed stories to the planned number of stories. The formula is: Agile Process Story Completion Rate = (Number of Completed Agile Stories ÷ Number of Planned Agile Stories) × 100%; Requirements delivery cycle: This metric measures the total time required from the submission of a requirement to its successful delivery and deployment. The length of the requirements delivery cycle directly affects the speed at which the business can acquire software functions and is an important indicator for measuring R&D efficiency. Sprint throughput: This metric reflects a team’s productivity during a sprint cycle by calculating the total story points earned during a sprint. Team Productivity: This metric measures the overall productivity of a team by the ratio of planned completed work to the amount of work put in. The formula is: Team Productivity = (Work Completed, such as Story Points or Feature Points, ÷ Work Put in, such as Man-Days or Man-Months). However, the existing solutions have the following drawbacks: (1) In order to achieve the story completion rate target, the team ignores quality and scope, and only focuses on "the number of completed" stories. This may result in sacrificing quality (such as code test coverage) or narrowing the scope of stories (breaking them down too finely to meet the quantity target). In order to improve the story completion rate, the team tends to choose low-risk and simple user stories when making plans, and avoid complex but valuable requirements in order to improve the completion rate; (2) Ignoring differences in story complexity: The throughput of completing 10 low-complexity stories may be higher than that of 1 high-complexity story, but the latter is actually more valuable. Teams may inflate story points to increase throughput, creating a "speed bubble"; (3) Single-dimensional team efficiency: Efficiency is measured solely by throughput, ignoring implicit investments such as collaboration costs, communication, and handling technical debt. This single-dimensional efficiency approach may incentivize short-term behavior, such as achieving high productivity through overtime or exploiting the team, leading to team overload or talent loss. It may also neglect quality and innovation; the team may reduce restructuring, automation, or exploratory work in pursuit of increased productivity, harming long-term sustainability. (4) Traditional R&D efficiency measurement methods often focus on static indicators such as story completion rate and story points, neglecting in-depth analysis of the diversity of task types, the number of deliverables and team working hours, making it difficult to accurately assess team efficiency and identify efficiency bottlenecks. Due to the rough task classification, fragmented data dimensions and insufficient root cause mining, the team is trapped in the dilemma of "knowing that it is inefficient but not knowing how to optimize it". Summary of the Invention
[0007] To address the aforementioned technical issues, this invention proposes a research and development efficiency measurement method based on agile software engineering. The aim is to provide a more comprehensive and dynamic method for measuring agile research and development efficiency. By clarifying the type of each task, identifying the types of task deliverables, and counting the number of task deliverables, and combining this with the time spent completing the deliverables, a "task type-deliverable-time" relationship is established. This allows for the measurement of the team's time investment and output for each type of deliverable, analysis of whether the investment and output are reasonable, identification and optimization of efficiency problems, and continuous improvement of efficiency.
[0008] This invention is achieved using the following technical solution: A method for measuring R&D effectiveness based on agile software engineering includes the following steps: Step S1: Select a project management tool based on team needs, and use the project management tool to establish the relationship between each work unit and the requirements; Step S2: Define the task type and deliverable type, and create deliverable tags according to different deliverable types; Step S3: Team members fill in a daily log in the project management tool, using the selected project management tool to record task and log information; Step S4: Export task and log data from the project management tool, process the data using a data processing pipeline automation tool, generate task type and throughput tables, user stories and throughput tables, analyze the data in the task type and throughput tables and user stories and throughput tables, and identify team performance issues.
[0009] Specifically, the log content in step S3 includes: Deliverable Address: The link address where the task deliverables are stored; Throughput: Different types of tasks correspond to different deliverables, and different types of throughput are counted. The types of tasks for which throughput needs to be counted include: requirements specification documents, requirements prototype design, UI design, technical solution design, front-end development code, back-end development code, mobile development code, test cases, test execution, defects generated by tests, operation and maintenance documents, and operation and maintenance work orders.
[0010] Specifically, the data processing in step S4, which involves the automation tool for the data processing pipeline, includes: Data validation: Based on log validation throughput format, check whether the deliverable address is a valid URL, verify the correctness of the task type, and check the matching of tags and task types; Data statistics: Aggregate effective working hours and business values by task type and tag, and aggregate throughput data by related requirements and task type; Record deliverables: dynamically generate a label column; Output files: Generate task type and throughput tables, user stories and throughput tables, and merge the two statistical tables into different sheets of a single Excel file.
[0011] Specifically, the script flow of the data processing pipeline automation tool further includes, in sequence: code merging, data repair, throughput statistics by demand, throughput statistics by sprint, and statistics of traceability information, wherein code merging specifically includes: In the main program, create an ArgumentParser object, add the project parameter, sprint parameter, task parameter, and hour parameter in sequence, and parse the command line parameters; Configure and call the `merge excel flies` function as the core function. It reads the task sheet Excel file and the time sheet Excel file respectively, standardizes the column names of the two tables, performs the `pd.merge` operation, creates a duplicate marker column, constructs the output file name and saves the results to an Excel file, and prints the completion information.
[0012] Specifically, the data repair includes: Parse the project and sprint parameters and call the repair excel function; Read an Excel file and filter out rows with empty fields; Fill in the missing labels according to the description, save the corrected data to a new Excel file, and print the completion message.
[0013] Specifically, the on-demand throughput statistics include: Parse the project and sprint parameters, call the process excel function, and read the repaired new Excel file; Create a task type column from the task title slice, and extract the throughput description column using regular expressions; Generate a regular expression pattern for business keywords, iterate through all business keyword patterns, create corresponding numerical columns and extract data from the throughput description column, save the processing results to a new Excel file, and print the completion information.
[0014] Specifically, the throughput statistics by sprint include: Parse the command-line project and sprint parameters, call the stat_print_data function, and read the Excel file containing the data processing results. Perform preprocessing, fill empty values in the label column with none, initialize the aggregation configuration, and extract all throughput metrics from the external mapping; Add the throughput metric to the aggregation configuration, perform grouped aggregations by task type and tag, build and rename the result set table, and calculate and add total rows to the result table; Save the statistical results to Excel, then reload the Excel file to set cell styles; Iterate through the data rows and determine whether the result is empty or nonexistent; if so, mark the background of the row; otherwise, keep the default style. Save the modified file and print the completion message.
[0015] Specifically, the statistics of the traceability information include: Parse the command-line parameter inputfilename to read the original Excel file and the Excel file containing the processed data. Extract all unique labels and create a new DataFrame structure containing columns of basic information; Iterate through each unique label, dynamically generating a label column through label processing loop; after the loop ends, save the statistical results file and print the completion message.
[0016] The beneficial effects of this invention are as follows: This solution, through dynamic correlation analysis of "task type-deliverable-work hours," expands the team's focus from the number of completed stories and story points to task type, deliverables, and corresponding work hours. This transforms performance evaluation from "fuzzy perception" to "precise quantification," and optimization decisions from "experience-driven" to "data-driven," providing a feasible and sustainable path for agile teams to improve performance. During implementation, team members use automated project management tools to input task information, deliverables, and actual work hours, ensuring the accuracy and security of the information. After the sprint, based on the obtained sprint task, deliverable, and work hour data, an automated program generates a summary of sprint information. The team can then analyze the data to determine if task allocation is reasonable, whether there is waste, and whether bottlenecks exist. Root cause analysis identifies problems, allowing for targeted improvement measures to enhance team performance. Attached Figure Description
[0017] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on the structures shown in these drawings without creative effort.
[0018] Figure 1 This is a schematic diagram of the operation process of the R&D efficiency measurement method based on agile software engineering in an embodiment of the present invention; Figure 2This is a flowchart of the first step of the script for the data processing pipeline automation tool in this embodiment; Figure 3 This is a flowchart of the second step of the script for the data processing pipeline automation tool in this embodiment; Figure 4 This is a flowchart of the third step of the script for the data processing pipeline automation tool in this embodiment; Figure 5 This is a flowchart of the fourth step of the script for the data processing pipeline automation tool in this embodiment; Figure 6 This is a flowchart of the fifth step of the script for the data processing pipeline automation tool in this embodiment; Detailed Implementation
[0019] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations.
[0020] It should be noted that similar labels and letters in the following figures indicate similar items. Therefore, once an item is defined in one figure, it does not need to be further defined and explained in subsequent figures.
[0021] The following is in conjunction with the appendix Figures 1-6 The following describes some embodiments of the present invention in detail. Unless otherwise specified, the following embodiments and features can be combined with each other.
[0022] This invention proposes a research and development efficiency measurement method based on agile software engineering. In a preferred embodiment, it includes the following steps: Step S1: Select a project management tool based on team needs, and use the project management tool to establish the relationship between each work unit and the requirements; Step S2: Define the task type and deliverable type, and create deliverable tags according to different deliverable types; Step S3: Team members fill in a daily log in the project management tool, using the selected project management tool to record task and log information; Step S4: Export task and log data from the project management tool, process the data using a data processing pipeline automation tool, generate task type and throughput tables, user stories and throughput tables, analyze the data in the task type and throughput tables and user stories and throughput tables, and identify team performance issues.
[0023] The following detailed description is provided with reference to specific embodiments: Example 1 A method for measuring R&D effectiveness based on agile software engineering, with the following operational process: Figure 1 Specifically, it includes: (1) Selecting project management tools Depending on the characteristics and needs of each team, a suitable project management tool can be selected or developed. Currently, commonly used project management tools on the market include ZenTao and JIRA.
[0024] The project management tool must support establishing a clear association between all work units (tasks, logs, test cases, bugs) and the final "requirements." It should have the functionality to import and export requirements, tasks, logs, test cases, and bugs. Core functional modules include: (a) Demand Management Function Description: Enables the creation, editing, and management of user stories, product requirements, or business requirements. This is the starting point and "single source of truth" for all work. Key capabilities: Support for detailed descriptions, priorities, and status management (e.g., pending, under development, released) of requirements. It must be possible to directly associate one or more tasks, multiple test cases, and multiple bugs with this requirement.
[0025] (b) Task Management Function Description: Break down macro-level requirements into specific, actionable, and assignable development, design, or other types of work items; Key capabilities: Support for task creation, assignment, estimated time, deadlines, and status progression (e.g., not started, in progress, completed, blocked). When creating a task, it must be possible to select and associate it with a specific requirement. A task should not be without a source. Tasks should include a work log to record progress and issues.
[0026] (c) Work log / work hour record Function Description: Provides real-time, detailed recording of the task execution process; Key capability: Team members can record daily work content, time spent, problems encountered, and next steps for specific tasks. Logs must exist as sub-items of tasks, clearly showing the complete execution history of that task.
[0027] (d) Test case management Function Description: Systematically write, organize, and manage test steps used to verify that requirements are correctly implemented; Key capabilities: Support for test case creation, editing, categorization (e.g., functional testing, integration testing), and version management. When creating a test case, it must be able to be associated with the requirement it is intended to verify. This ensures the test's relevance. After executing a test case, the execution result (pass / fail) needs to be recorded, and bugs should be directly created from failed test cases.
[0028] (e) Defect Management Function Description: To systematically record, track, and resolve issues discovered during testing or use; Key capabilities: Support for bug submission, assignment, status management (e.g., pending confirmation, assigned, fixed, verified, closed), and severity level classification. When creating a bug, it must be able to associate it with: the test case that discovered the issue (if discovered by tests), the requirements affected by the bug, and related tasks, so that developers can quickly locate the problematic code.
[0029] II. Clarify the task type Taking software development projects as an example, there are eight task types: requirements, design, development, testing, operations, meetings, management, and others. Different task types correspond to different deliverables. Based on these deliverable types, the agile coach creates deliverable tags in the system. The agile coach or team members then associate each task with a deliverable tag.
[0030] III. Writing a Daily Log Team members fill out a daily log in the project management tool, including the log date, log content, and work hours. The log content is divided into two items: [Deliverable Address] and [Throughput].
[0031] IV. Use the selected project management tool to record the above tasks and logs. Using the selected project management tool to record the above task and log information, you can export a "Task and Log Information Table" from the project management tool.
[0032] V. Use automated tools such as "data processing pipelines" to process data. Prepare "automated data processing scripts"; Export the "Task and Log Information Table" from the project management tool; The "Automated Data Processing Script" is used to process the "Task and Log Information Table" to generate the "Task Type and Throughput Table" and the "User Story and Throughput Table," as shown in Table 1 and Table 2.
[0033] Table 1 Task Type and Throughput Table Table 2 User Stories and Throughput Table In this embodiment, the process of generating the "Task Type and Throughput Table" includes: the script automatically extracts task type data, deliverable tag data, actual working hours data, and throughput data from the "Task and Log Information Table", summarizes the working hours and throughput according to task type and deliverable tag, and outputs the "Task Type and Throughput Table".
[0034] The process of generating the "User Story and Throughput Table" is as follows: The script automatically extracts the task type, user story, actual working hours, and throughput, and summarizes the working hours and throughput according to the user story and task type; and outputs the "User Story and Throughput Table".
[0035] In this embodiment, the core logic of the automated data processing script is as follows: Figures 2-6 As shown, the code merging process specifically includes: In the main program, create an ArgumentParser object, add the project parameter, sprint parameter, task parameter, and hour parameter in sequence, and parse the command line parameters; Configure and call the `merge excel flies` function as the core function. It reads the task sheet Excel file and the time sheet Excel file respectively, standardizes the column names of the two tables, performs the `pd.merge` operation, creates a duplicate marker column, constructs the output file name and saves the results to an Excel file, and prints the completion information.
[0036] Data repair specifically includes: Parse the project and sprint parameters and call the repair excel function; Read an Excel file and filter out rows with empty fields; Fill in the missing labels according to the description, save the corrected data to a new Excel file, and print the completion message.
[0037] The throughput statistics based on demand specifically include: Parse the project and sprint parameters, call the process excel function, and read the repaired new Excel file; Create a task type column from the task title slice, and extract the throughput description column using regular expressions; Generate a regular expression pattern for business keywords, iterate through all business keyword patterns, create corresponding numerical columns and extract data from the throughput description column, save the processing results to a new Excel file, and print the completion information.
[0038] The throughput statistics by sprint include: Parse the command-line project and sprint parameters, call the stat_print_data function, and read the Excel file containing the data processing results. Perform preprocessing, fill empty values in the label column with none, initialize the aggregation configuration, and extract all throughput metrics from the external mapping; Add the throughput metric to the aggregation configuration, perform grouped aggregations by task type and tag, build and rename the result set table, and calculate and add total rows to the result table; Save the statistical results to Excel, then reload the Excel file to set cell styles; Iterate through the data rows and determine whether the result is empty or nonexistent; if so, mark the background of the row; otherwise, keep the default style. Save the modified file and print the completion message.
[0039] The statistics on traceability information specifically include: Parse the command-line parameter inputfilename to read the original Excel file and the Excel file containing the processed data. Extract all unique labels and create a new DataFrame structure containing columns of basic information; Iterate through each unique label, dynamically generating a label column through label processing loop; after the loop ends, save the statistical results file and print the completion message.
[0040] VI. Data Analysis The team analyzed the data in the "Task Type and Throughput Table" and the "User Story and Throughput Table" to identify existing problems within the team.
[0041] Example 2 In this embodiment, based on agile project management, a "task type-deliverable-work hours" R&D performance measurement method is implemented. Team members use automated project management tools to input task information, deliverables, and actual work hours during implementation, ensuring the accuracy and security of the information. After the sprint, based on the obtained sprint task, deliverable, and work hour data, an automated program generates sprint information summary data. The team can analyze the data to determine if task allocation is reasonable, whether there is waste, and whether bottlenecks exist. Root cause analysis identifies problems, and targeted improvement measures are developed to enhance team performance management tools. The specific implementation process is as follows: I. Management Tools Determine the project management tools used by the team; these tools should have the following functions: creating user stories, creating tasks, creating deliverable tags, writing logs, and writing log hours. Tasks should be able to be associated with user stories, and tasks should be able to be associated with deliverable tags.
[0042] II. Clarify the task type Taking software development projects as an example, there are eight types of tasks: requirements, design, development, testing, operation and maintenance, meetings, management, and others.
[0043] III. Identify the types of deliverables and create deliverable labels. Different task types correspond to different deliverables. Based on the different deliverable types, the agile coach creates deliverable tags in the system. The agile coach or team members then associate each task with a deliverable tag. See Table 3, "Task Type - Deliverable Tag - Throughput Correspondence Table," for details.
[0044] IV. Team members fill in a log daily in the project management tool. The information to fill in includes: the date of the log entry, the log content, and the actual working hours spent. The log content is: [Throughput]; Table 3 Task Type - Deliverable Tag - Throughput Correspondence Table [Throughput]: Different types of tasks correspond to different deliverables, and throughput statistics are calculated for different types. See Table 3, Task Type - Deliverable Tag - Throughput Correspondence Table. When deliverables include requirement specifications, requirement prototype design, UI design, technical solution design, front-end development code, back-end development code, mobile development code, test cases, test execution, defects generated during testing, operation and maintenance documents, and operation and maintenance work orders, throughput statistics are required. Team members need to record the [Throughput] quantity in their logs.
[0045] Example: A task of type "requirement" has a deliverable of a "requirement specification document," which includes 3 completed functions (i.e., a total of 3 functions). The log entry for this task would be written as follows: Throughput: PRD [Number of functions: 3].
[0046] 5. Export the pending "Tasks and Log Information Table" from the project management tool. Export the pending "Tasks and Log Information Table" from the project management tool by date.
[0047] VI. Use automated tools such as "data processing pipelines" to process data. The data processing pipeline process: (a) Data validation: Verification log: Verify that the throughput format is correct. Check that the deliverable address is a valid URL; Verify task type: Verify the correctness of the task type. Check the match between the tag and the task type.
[0048] (b) Data statistics: Work Hour Summary: Aggregates valid work hours and business data by task type and tag; Throughput statistics: Aggregate throughput data by related demand and task type.
[0049] (c) Record the results: Dynamically generate a label column and map it to the delivery address; (d) Output file: Generate a "Task Type and Throughput Table" and a "User Story and Throughput Table"; Merge two statistical tables into different sheets of a single Excel file.
[0050] VII. Data Analysis The team analyzed existing problems by presenting data in the "Task Type and Throughput Table" and the "User Story and Throughput Table".
[0051] Compared to traditional R&D efficiency measurement methods, the proposed method in this invention helps teams overcome the dilemma of "knowing inefficiency but not knowing how to optimize." This method uses real data to help teams accurately pinpoint existing problems, including: 1. Efficiency and Productivity Issues High working hours but low delivery rate may be due to: insufficient skills, low communication efficiency, or unfamiliarity with tools. Large fluctuations in delivery volume may be caused by: inaccurate task estimation, frequent changes in requirements, or excessive external interference.
[0052] 2. Quality and technical debt issues An excessively high proportion of defect fixing tasks reflects problems such as insufficient test coverage or poor code quality. It also indicates inadequate delivery of technical debt; the long-term impact is a decline in future development efficiency.
[0053] 3. Resource allocation and skills issues Uneven distribution of working hours for a certain task type is typically manifested in: low efficiency for that specific task type; team weaknesses: lack of relevant skills or insufficient training.
[0054] 4. Process and Collaboration Issues Defect overflow during the testing phase, process loopholes: insufficient test coverage or process compression. Insufficient cross-functional collaboration; typical manifestation: tasks are concentrated in a single function (such as an imbalance between development and testing).
[0055] For the foregoing embodiments, in order to simplify the description, they are all described as a series of actions. However, those skilled in the art should understand that this application is not limited to the described order of actions, because according to this application, some steps can be performed in other orders or simultaneously. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions involved are not necessarily essential to this application.
[0056] The above embodiments describe the basic principles, main features, and advantages of the present invention. Those skilled in the art should understand that the present invention is not limited to the above embodiments. The embodiments and descriptions in the specification are merely illustrative of the principles of the invention. Modifications and variations made by those skilled in the art without departing from the spirit and scope of the invention should be within the protection scope of the appended claims.
Claims
1. A method for measuring R&D effectiveness based on agile software engineering, characterized in that, Includes the following steps: Step S1: Select a project management tool based on team needs, and use the project management tool to establish the relationship between each work unit and the requirements; Step S2: Define the task type and deliverable type, and create deliverable tags according to different deliverable types; Step S3: Team members fill in a daily log in the project management tool, using the selected project management tool to record task and log information; Step S4: Export task and log data from the project management tool, process the data using the data processing pipeline automation tool, generate task type and throughput tables, user stories and throughput tables, analyze the task type and throughput tables, and analyze the user story and throughput table data to identify team performance issues.
2. The R&D efficiency measurement method based on agile software engineering as described in claim 1, characterized in that, The log content in step S3 includes: Deliverable Address: The link address where the task deliverables are stored; Throughput: Different types of tasks correspond to different deliverables, and different types of throughput are counted. The types of tasks for which throughput needs to be counted include: requirements specification documents, requirements prototype design, UI design, technical solution design, front-end development code, back-end development code, mobile development code, test cases, test execution, defects generated by tests, operation and maintenance documents, and operation and maintenance work orders.
3. The R&D efficiency measurement method based on agile software engineering as described in claim 1, characterized in that, The data processing in step S4, which involves the automation tool for the data processing pipeline, includes: Data validation: Based on log validation throughput format, check whether the deliverable address is a valid URL, verify the correctness of the task type, and check the matching of tags and task types; Data statistics: Aggregate effective working hours and business values by task type and tag, and aggregate throughput data by related requirements and task type; Record deliverables: Dynamically generate a label column and map it to the deliverable address; Output files: Generate task type and throughput tables, user stories and throughput tables, and merge the two statistical tables into different sheets of a single Excel file.
4. The R&D efficiency measurement method based on agile software engineering as described in claim 3, characterized in that, The script flow of the data processing pipeline automation tool also includes, in sequence: code merging, data repair, throughput statistics based on demand, throughput statistics based on sprints, and statistics of traceability information. Specifically, code merging includes: In the main program, create an ArgumentParser object, add the project parameter, sprint parameter, task parameter, and hour parameter in sequence, and parse the command line parameters; Configure and call the `merge excel flies` function as the core function. It reads the task sheet Excel file and the time sheet Excel file respectively, standardizes the column names of the two tables, performs the `pd.merge` operation, creates a duplicate marker column, constructs the output file name and saves the results to an Excel file, and prints the completion information.
5. The R&D efficiency measurement method based on agile software engineering as described in claim 4, characterized in that, The data repair specifically includes: Parse the project and sprint parameters and call the repair excel function; Read an Excel file and filter out rows with empty fields; Fill in the missing labels according to the description, save the corrected data to a new Excel file, and print the completion message.
6. The method for measuring R&D efficiency based on agile software engineering as described in claim 5, characterized in that, The specific components of the demand-based throughput statistics include: Parse the project and sprint parameters, call the process excel function, and read the repaired new Excel file; Create a task type column from the task title slice, and use regular expressions to extract and create a deliverable address column and a throughput description column; Generate a regular expression pattern for business keywords, iterate through all business keyword patterns, create corresponding numerical columns and extract data from the throughput description column, save the processing results to a new Excel file, and print the completion information.
7. The R&D efficiency measurement method based on agile software engineering as described in claim 6, characterized in that, The throughput statistics based on sprint specifically include: Parse the command-line project and sprint parameters, call the stat_print_data function, and read the Excel file containing the data processing results. Perform preprocessing, fill empty values in the label column with none, initialize the aggregation configuration, and extract all throughput metrics from the external mapping; Add the throughput metric to the aggregation configuration, perform grouped aggregations by task type and tag, build and rename the result set table, and calculate and add total rows to the result table; Save the statistical results to Excel, then reload the Excel file to set cell styles; Iterate through the data rows and determine whether the result is empty or nonexistent; if so, mark the background of the row; otherwise, keep the default style. Save the modified file and print the completion message.
8. The R&D efficiency measurement method based on agile software engineering as described in claim 7, characterized in that, The statistics of the traceability information specifically include: Parse the command-line parameter inputfilename to read the original Excel file and the Excel file containing the processed data. Extract all unique labels and create a new DataFrame structure containing columns of basic information; Iterate through each unique label, dynamically generating a label column through label processing loop; after the loop ends, save the statistical results file and print the completion message.
