Code development progress calculation method based on developer behavior patterns and electronic device

Abstract

The embodiment of the application relates to the technical field of code development management and control, in particular to a code development progress calculation method based on a developer behavior mode and an electronic device, and the embodiment of the application can effectively calculate the accurate code development progress of a target demand according to target time data and historical code data, realizes automatic, accurate and efficient calculation of the code development progress of the target demand, so that the developer can timely manage and control the code development progress of the target demand, and the development progress is as far as possible ensured from being affected, and the software development quality is improved.

Description

Technical Field

[0001] The embodiments of the present invention relate to the field of code development management technology, and in particular to a code development progress calculation method and electronic device based on developer behavior patterns. Background Technology

[0002] The software requirements development process is inherently uncertain and non-repetitive. Unlike traditional industries such as manufacturing, software development is essentially a knowledge-intensive and innovation-intensive endeavor, and its process is difficult to fully capture using simple quantitative indicators. Dynamic changes in requirements are the norm in the software development process; most software projects encounter frequent requirement changes during development. These changes directly lead to continuous adjustments to the initial technical solutions, resulting in inaccurate workload estimates.

[0003] Tasks initially estimated to be simple often reveal unexpected complexities during development. These complexities may stem from various factors, such as technical implementation difficulties, system integration and compatibility issues, or underlying architectural constraints. This characteristic makes it impossible to accurately estimate the total amount of code required in the early stages of a project. Therefore, traditional methods of measuring project progress based on the total amount of code are often unsuitable and may even produce seriously misleading results.

[0004] Traditional progress assessment methods, such as the percentage-of-tasks method and the time-consuming ratio method, while still valuable in certain scenarios, have increasingly apparent limitations. These methods are typically based on the assumption of a "linear distribution of workload," failing to adequately consider the time investment required for innovative work and unexpected challenges in software development. This leads to the "90% completion trap" (where the last 10% of the work often consumes 30% of the resources) becoming a common phenomenon, resulting in significant errors in development progress assessment and potentially causing project delays or poor quality. Summary of the Invention

[0005] In view of this, one objective of the embodiments of the present invention is to provide a code development progress calculation method and electronic device based on developer behavior patterns, so as to improve the situation where the error in the code development progress assessment of software requirements is large in the related art.

[0006] To address the aforementioned technical problems, the embodiments of the present invention provide the following technical solutions:

[0007] In a first aspect, embodiments of the present invention provide a method for calculating code development progress based on developer behavior patterns, including:

[0008] Obtain the target time data corresponding to the target requirement. The target time data includes the standard working hours of one or more first R&D personnel and the target submission time. The target submission time is the time when the first R&D personnel first submits code to the target requirement.

[0009] Obtain historical code data, which includes at least one historical requirement and corresponding code reference data. The code reference data includes the total amount of code submitted by one or more second developers within a first historical time period, the number of code submissions, and the amount of code submitted and the submission time corresponding to the number of code submissions. The total amount of code submissions is the sum of the amount of code submitted to the historical requirement by all second developers. The total amount of code submissions is greater than or equal to a first quantity threshold and less than or equal to a second quantity threshold. The length of the first historical time period is less than or equal to the first time length, and the difference between the last submission time and the target submission time within the first historical time period is less than or equal to the second time length. The last submission time is the time when the second developer last submitted code to the historical requirement. The first developer is one of the one or more second developers.

[0010] Based on historical code data and target time data, the code development progress for the target requirements is calculated.

[0011] In a second aspect, embodiments of the present invention provide an electronic device, comprising:

[0012] A processor and a memory communicatively connected to the processor;

[0013] The memory stores computer program instructions executable by the processor, which, when executed by the processor, cause the electronic device to perform any of the code development progress calculation methods based on developer behavior patterns proposed in the first aspect.

[0014] The embodiments of the present invention have the following beneficial effects: Unlike the prior art, the code development progress calculation method based on developer behavior patterns provided by the embodiments of the present invention cleans and filters the original historical code data from two key dimensions: time relevance and consistency of development activity scale. This constructs a high-quality, high-reference-value, and highly consistent dataset (i.e., historical code data), thereby enabling the determination of developers' development behavior patterns based on accurate and reliable historical code data. Furthermore, due to the stability of individual developers' development behavior, the method can effectively calculate the development progress of developers after submitting code at each time node based on target time data and historical code data. The calculated development progress is then used as the code development progress for the target requirements. In this way, the code development progress for the target requirements is calculated automatically, accurately, and efficiently, enabling developers to manage the code development progress for the target requirements in a timely manner, ensuring that the development progress is not affected as much as possible, and improving the quality of software development. Attached Figure Description

[0015] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the accompanying drawings used in the description of the prior art or embodiments will be briefly introduced below. Obviously, the drawings described below only show some embodiments of the present invention and should not be considered as limiting the scope of protection. For those skilled in the art, other related drawings can be obtained based on these drawings without creative effort.

[0016] Figure 1 This is a schematic diagram illustrating an application scenario of the code development progress calculation method based on developer behavior patterns provided in some embodiments of the present invention;

[0017] Figure 2 These are schematic diagrams of the structure of an electronic device provided in some embodiments of the present invention;

[0018] Figure 3 This is a flowchart illustrating a code development progress calculation method based on developer behavior patterns provided in some embodiments of the present invention.

[0019] Figure 4 yes Figure 3 A schematic diagram of a sub-process of step S300 in the code development progress calculation method based on developer behavior patterns shown in the embodiment;

[0020] Figure 5 yes Figure 3 This is a schematic diagram of another sub-process of step S300 in the code development progress calculation method based on developer behavior patterns shown in the embodiment. Detailed Implementation

[0021] To make the objectives and advantages of the embodiments of the present invention more readily understood, 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 a part of the embodiments of the present invention, and not all of them. The detailed description of the embodiments of the present invention in the accompanying drawings is not intended to limit the scope of protection claimed by the present invention, but only to illustrate selected embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0022] It should be noted that, unless there is a conflict, the various technical features involved in the embodiments of the present invention described below can be combined with each other, and all are within the protection scope of the present invention. Furthermore, although functional modules are divided in the device or structural schematic diagram and a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than the module division in the device or the order in the flowchart. In addition, the terms "first," "second," "third," and other similar expressions used herein do not limit the data or execution order, but are only for illustrative purposes and to distinguish identical or similar items with substantially the same function and effect, and should not be construed as indicating or implying relative importance or implicitly specifying the number of technical features.

[0023] Unless otherwise defined, the technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art. The terminology used herein is for the purpose of describing particular embodiments only and is not intended to limit the invention. It should be understood that the term "and / or" as used herein includes any and all combinations of one or more of the listed items.

[0024] From the perspective of individual developer behavior, their coding behavior in multi-task concurrent environments exhibits significant and identifiable patterns. These behavioral patterns integrate technical skills, work habits, and professional qualities, possessing high personal characteristics and demonstrating reproducible stability in cross-project and cross-task development activities.

[0025] A developer's coding habits (such as code commit frequency, modification methods, and testing behavior) are significantly correlated with code quality issues. For example, developers who frequently commit small changes tend to have higher code quality, while developers who don't commit for a long time and make large changes are more likely to introduce complex problems. These behavioral characteristics can be detected, classified, and interpreted through data mining, thereby enabling an objective evaluation of developer performance.

[0026] The stability of developer behavior patterns provides a new theoretical basis for progress assessment. Therefore, constructing "development characteristic models" at the individual developer level based on massive amounts of historical behavioral data, and then effectively inferring the current development progress, has become a feasible technical approach.

[0027] Based on this approach, this application proposes a data-driven and personalized modeling method for calculating development progress. It shifts from macroscopic, vague estimation of the total project volume to a microscopic modeling method based on individual behavioral data. This method no longer relies on easily inaccurate code volume estimates, but focuses on measurable and quantifiable analysis of individual developer behavioral characteristics, achieving reliable progress inferences by constructing personalized models.

[0028] Please see Figure 1 , Figure 1 The illustration shows an application scenario diagram of the code development progress calculation method based on developer behavior patterns provided by some embodiments of the present invention.

[0029] like Figure 1 As shown, the application scenario includes an electronic device 100, a first engine 10, and a second engine 20. The electronic device 100 communicates with the first engine 10 and the second engine 20 via a network. It can be understood that examples of networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof.

[0030] For example, in practical applications of software development management, the first engine 10 is used to collect and provide requirements and corresponding data information (such as standard working hours for R&D personnel and their allocation). Users (such as project managers) can publish requirements and corresponding data information on the first engine 10. The first engine 10 will collect multiple requirements and corresponding data information for the same version of the same project to form requirement data, and store the requirement data in local storage, cloud server, or other suitable media. In this embodiment of the invention, the first engine 10 can be the project management tool "Redmine" or other suitable systems, tools, software, or devices, etc., and this embodiment of the invention does not impose any limitations on this.

[0031] In some embodiments, the electronic device 100 obtains the target requirements and corresponding data information of the target version from the first engine 10 via a network. The target version is a version in the development stage of one or more versions of a software project. It is understood that requirements refer to a description of the functions that the software system needs to implement. For example, if the required function is to count the number of patents and patent applications, then the requirement could be to count the number of patents and patent applications within any time period, and to perform multi-faceted statistics based on application type, application time, authorization status, and legal status. Clearly, any requirement in the target version can serve as a target requirement, which refers to the requirements during the software code development stage by developers / R&D personnel.

[0032] It should be understood that the same target version of a project includes one or more requirements. A requirement can be divided into multiple detailed sub-requirements, and multiple sub-requirements correspond to the same requirement. For example, if the requirement is to implement a function to count the number of patents and patent applications, then the multiple sub-requirements may include patent entry requirements, patent information (such as application time, application type, and whether it has been granted) acquisition requirements, and patent statistics requirements, etc. Requirements will be assigned to specific R&D personnel, including front-end developers and back-end developers. It can be understood that solving a requirement may only require front-end developers, or only back-end developers, or both. When creating each requirement, the standard working hours for front-end developers and / or back-end developers in each requirement are preset, so that each requirement has corresponding standard working hours (i.e., the working hours required for front-end developers and / or back-end developers to participate in solving each requirement). The standard working hours corresponding to the requirement are used by project managers or management personnel to control and manage the resource status of R&D personnel, the project testing and delivery schedule, etc., to promote the software project development progress.

[0033] For example, the second engine 20 is used to collect and provide historical code data. This historical code data includes at least one historical requirement and corresponding code reference data. The code reference data includes the total amount of code submissions made by developers within a specific historical time period, the number of code submissions, the amount of code submitted each time (i.e., the amount of code submitted for each submission), the submission time, and the submitter. The code reference data is associated with historical requirements; that is, it is data related to code submissions for a specific requirement. Users (such as developers) can submit code data to the second engine 20. The second engine 20 will collect the code data for the same historical requirement, recording the total amount of code submissions, the number of code submissions, the amount of code submitted each time, the submission time, and the submitter, thus forming the code reference data. The second engine 20 will summarize the code reference data for each historical requirement to obtain historical code data, and store the historical code data in local storage, a cloud server, or any other suitable storage medium. In this embodiment of the invention, the second engine 20 can be a project code management system like "GitHub" or any other suitable platform, tool, software, or device; this embodiment of the invention does not impose any limitations on this.

[0034] Specifically, in this embodiment of the invention, target time data corresponding to the target requirement is obtained from the first engine 10. The target time data includes the standard working hours of one or more first R&D personnel and the target submission time. The target submission time is the time when the first R&D personnel first submit code to the target requirement.

[0035] This embodiment of the invention obtains historical code data from the second engine 20. The historical code data includes at least one historical requirement and corresponding code reference data. The code reference data includes the total amount of code submitted by one or more second developers within a first historical time period, the number of code submissions, the amount of code submitted corresponding to each submission (i.e., the amount of code submitted by the second developer within that number of submissions), and the submission time. The total amount of code submitted is the sum of the amount of code submitted to the historical requirement by all second developers. The total amount of code submitted is greater than or equal to a first quantity threshold and less than or equal to a second quantity threshold. The length of the first historical time period is less than or equal to a first time length, and the difference between the last submission time and the target submission time within the first historical time period is less than or equal to a second time length. The last submission time is the time when a second developer last submitted code to the historical requirement, and the first developer is one of one or more second developers.

[0036] Finally, based on historical code data and target time data, this embodiment of the invention calculates the code development progress for the target requirements.

[0037] In the data preprocessing stage, this invention implements a multi-dimensional historical data filtering strategy. This strategy cleans and filters the original historical code data from two key dimensions—time relevance and scale consistency—through a series of preset conditions, thereby constructing a high-quality dataset with high reference value.

[0038] The first dimension involves data constraints based on temporal proximity. Firstly, the condition that "the length of the first historical time period is less than or equal to the first time length" filters out requirements with abnormally long development cycles. Excessively long development cycles usually indicate that the requirement encountered significant technical obstacles, drastic changes in the scope of the requirement, or severe under-resource allocation, making its development pattern unreliable for general reference. Secondly, the condition that "the difference between the last commit time and the target commit time within the first historical time period is less than or equal to the second time length" ensures that the selected historical requirements are sufficiently close in time to the target requirements. Software development technologies, tools, and practices evolve rapidly; historical data from too far back may reflect developer skill levels, technology stacks, and collaboration patterns that differ significantly from the present, thus reducing its reference value.

[0039] The second dimension is based on the consistency constraint of development activity scale. The condition that "the total number of code commits is greater than or equal to the first threshold and less than or equal to the second threshold" is used to exclude historical requirements with abnormally large or small code sizes. Requirements that are too small (such as those that only modify a few lines of code) may not reflect the complete development process and decision-making process; while requirements that are too large (such as those involving system refactoring) may contain too much specificity and complexity. Retaining requirements of moderate size helps to find reference samples that are more in line with the development scale of the target requirements.

[0040] Through the aforementioned multi-dimensional collaborative screening, this invention initially ensures that the historical code data used for modeling possesses the following characteristics: high reference value, as the retained requirement data shares similar development environment, technical background, and target requirements, and the development scale and cycle are within a normal range, better reflecting the stable and typical behavioral patterns of the development team; high quality, effectively eliminating "noise data" caused by special events, abnormal situations, or data recording errors, laying a solid data foundation for subsequently building an accurate developer behavior characteristic model; and high consistency, as the screened dataset is more concentrated in terms of time, scale, and activity patterns, reducing the interference of irrelevant variables and improving the interpretability and predictive stability of the progress calculation model.

[0041] This data filtering process is a crucial foundation for the entire code development progress calculation method based on developer behavior patterns. It ensures the effectiveness and reliability of subsequent progress calculations, providing high-quality data input for accurate progress inference at the micro-level of individual behavior.

[0042] This invention employs a series of preset conditions to filter and obtain historical code data, ensuring the accuracy and high reference value of the historical code data. This allows for the determination of the developer's development mode based on accurate and reliable historical code data. Furthermore, due to the stability of individual developer behavior, the development progress of developers after submitting code at various time points can be effectively calculated based on historical code data and target time data. The calculated development progress is then used as the code development progress for the target requirements. In this way, the code development progress for the target requirements is calculated automatically, accurately, and efficiently, enabling developers to manage the code development progress of the target requirements in a timely manner, ensuring that the development progress is not affected as much as possible, and improving the quality of software development.

[0043] It should be understood that, Figure 1In the application scenario shown, the electronic device 100 is a laptop computer. This does not limit the structure, type, quantity, or method of obtaining target time data and historical code data of the electronic device 100 in other application scenarios or embodiments. For example, in some other application scenarios or embodiments, the electronic device can also be a desktop computer, a microcontroller, a tablet computer, or other suitable type of device or apparatus. The target time data and historical code data are stored on the same storage medium, and the electronic device can directly obtain the target time data and historical code data from one storage medium without having to obtain the target time data and historical code data from multiple engines separately.

[0044] To facilitate understanding of the code development progress calculation method based on developer behavior patterns provided in the embodiments of the present invention, the electronic device provided in the embodiments of the present invention will first be described in detail.

[0045] Please see Figure 2 , Figure 2 The schematic diagram illustrates the structure of an electronic device provided by some embodiments of the present invention.

[0046] like Figure 2 As shown, the electronic device 100 includes at least one processor 110 and a memory 120 connected in communication. Figure 2 Taking a bus system 130 and a processor 110 as an example, the various components in the electronic device 100 are coupled together through the bus system 130, which is used to realize the connection and communication between the various components. It is easy to understand that the bus system 130 may include, in addition to the data bus, a power bus, a control bus, and a status signal bus, etc. However, for the sake of clarity and brevity, in... Figure 2 The general labels all buses as Bus System 130. Understandably, Figure 2 The structures shown in the embodiments are merely illustrative and do not limit the structure of the electronic device described above. For example, the electronic device may also include components that are larger than... Figure 2 The structure shown has more or fewer components, or has the same as Figure 2 The diagram shows different configurations of the structure.

[0047] Specifically, the processor 110 provides computational and control capabilities to support the electronic device 100 in executing corresponding business logic and functions. For example, it supports the electronic device 100 in executing the code development progress calculation method based on developer behavior patterns provided in this embodiment of the invention, or in executing steps in any possible implementation of the code development progress calculation method based on developer behavior patterns provided in this embodiment of the invention. Those skilled in the art will understand that the processor 110 can be a general-purpose processor, including a central processing unit (CPU), a network processor (NP), etc.; it can also be a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components.

[0048] The memory 120, as a non-transitory computer-readable storage medium, can be used to store non-transitory software programs, non-transitory computer-executable programs, instructions, and modules, such as the program and instructions / modules corresponding to the code development progress calculation method based on developer behavior patterns in this embodiment of the invention. In some embodiments, the memory 120 may include a program storage area and a data storage area. The program storage area may store the operating system and applications required for at least one function, while the data storage area may store data created according to the use of the processor 110. The processor 110 executes various functional applications and data processing of the electronic device 100 by running the non-transitory software programs, instructions, and modules stored in the memory 120, thereby implementing the code development progress calculation method based on developer behavior patterns provided in this embodiment of the invention, or executing the steps in any possible implementation of the code development progress calculation method based on developer behavior patterns provided in this embodiment of the invention. In some embodiments, the memory 120 may include high-speed random access memory and may also include non-transitory memory. For example, at least one disk storage device, flash memory device, or other non-transitory solid-state storage device. In some embodiments, the memory 120 may also include memories remotely located relative to the processor 110, which can be connected to the processor 110 via a communication network. It is understood that examples of the aforementioned communication networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof.

[0049] As can be understood from the above, the implementing entity of any of the code development progress calculation methods based on developer behavior patterns provided in the embodiments of the present invention can be any suitable type of electronic device with certain computing and control capabilities, such as the aforementioned electronic device 100. In some feasible implementations, any of the code development progress calculation methods based on developer behavior patterns provided in the embodiments of the present invention can be implemented by a processor executing computer program instructions stored in memory.

[0050] The following will describe in detail the code development progress calculation method based on developer behavior patterns provided in the embodiments of the present invention, with reference to exemplary applications and implementations of the electronic devices provided in the embodiments of the present invention.

[0051] Please see Figure 3 , Figure 3 The illustration shows a flowchart of a code development progress calculation method based on developer behavior patterns provided in some embodiments of the present invention.

[0052] Those skilled in the art will understand that the code development progress calculation method based on developer behavior patterns provided in this embodiment of the invention can be applied to the aforementioned electronic device (e.g., electronic device 100). Specifically, the execution subject of this code development progress calculation method based on developer behavior patterns is one or at least two processors of the electronic device.

[0053] For example, see Figure 3 As shown, the code development progress calculation method based on developer behavior patterns includes, but is not limited to, the following steps S100-S300:

[0054] S100: Obtain the target time data corresponding to the target requirement.

[0055] In this step, the target time data includes the standard working hours and target submission time of one or more first R&D personnel. The first R&D personnel are the R&D personnel who participate in solving the target requirements. The standard working hours refer to the working hours required for the first R&D personnel to participate in solving the target requirements. The target submission time is the time when the first R&D personnel first submit code to the target requirements.

[0056] Specifically, in this embodiment of the invention, the target time data corresponding to the target demand is obtained from any suitable storage medium (e.g., the first engine 10) that stores the target time data corresponding to the target demand, or the storage medium transmits the target time data corresponding to the target demand to an electronic device.

[0057] S200: Retrieve historical code data.

[0058] In this embodiment, the historical code data includes at least one historical requirement and corresponding code reference data. The code reference data includes the total amount of code submitted by one or more second developers within a first historical time period, the number of code submissions, and the amount of code submitted and the submission time corresponding to the number of code submissions. The total amount of code submitted is the sum of the amount of code submitted to the historical requirement by all second developers. The total amount of code submitted is greater than or equal to a first quantity threshold and less than or equal to a second quantity threshold. The length of the first historical time period is less than or equal to a first time length, and the difference between the last submission time and the target submission time within the first historical time period is less than or equal to a second time length. The last submission time is the time when the second developer last submitted code to the historical requirement. The first historical time period refers to the time period during which one or more second developers submitted code to the historical requirement. The first developer is one of the one or more second developers, that is, the developer who submitted code data to the historical requirement.

[0059] In this step, engineers set preset conditions for filtering historical code data. Specifically, they filter out historical requirements and their code data with excessively long time spans by setting the condition "the length of the first historical time period is less than or equal to the first time length". They also filter out historical requirements and their code data that are far removed from the time of the first submission of the target requirement code by setting the condition "the difference between the last submission time and the target submission time within the first historical time period is less than or equal to the second time length". Finally, they filter out historical requirements and their code data with excessively large or small total code submissions by setting the condition "the total number of code submissions is greater than or equal to the first quantity threshold and less than or equal to the second quantity threshold". In this way, accurate historical code data can be obtained, ensuring the accuracy of historical code data.

[0060] For example, in embodiments of the present invention, code data that meets the preset conditions is selected from any suitable storage medium (e.g., the second engine 20) storing code data submitted by R&D personnel / developers / technical personnel, and the selected code data that meets the preset conditions is used as historical code data. Alternatively, the preset conditions are sent to the storage medium, the storage medium selects code data that meets the preset conditions as historical code data, and the historical code data is transmitted to an electronic device.

[0061] S300: Calculates the code development progress for the target requirements based on historical code data and target time data.

[0062] In this step, reference code data corresponding to the historical requirements submitted by the first developer is filtered out based on historical code data. This includes the total amount of code submissions, the number of code submissions, and the amount and time of code submissions corresponding to the number of code submissions within the first historical time period.

[0063] In this embodiment of the invention, when the first R&D personnel submits code to the target requirement at various time points, the code development progress of the target requirement at each time point is calculated based on the reference code data corresponding to the historical requirements submitted by the first R&D personnel in the selected historical code data and the target time data.

[0064] For example, historical code data is shown in Table 1 below:

[0065] Table 1:

[0066]

[0067] According to Table 1, the first R&D personnel include R&D personnel A and R&D personnel B. Then, the code reference data corresponding to historical requirements K1, K2 and K3 in the historical code data are selected. After detecting that the first R&D personnel submit code to the target requirements at each time node, the code development progress of the target requirements at each time node is calculated based on the code reference data corresponding to historical requirements K1, K2 and K3 and the target time data.

[0068] For example, when the code for the first target requirement is detected, based on the code submission volume of developers A and B when they first submitted code in the code reference data corresponding to historical requirements K1, K2, and K3, and the total number of code submission candidates corresponding to developers A and B, the historical development progress of developers A and B after their first submission to the historical requirement is calculated. That is, the historical development progress of developers A and B after their first submission to historical requirement K1 is calculated. The total number of code submissions from developer A in historical requirement K1 is [number missing]. Okay, the historical development progress of developer A after submitting code to historical requirement K1 for the first time is calculated as follows: Researcher A submitted the first version of the historical requirement K2. The total number of code submissions from developer A in historical requirement K2 is [number missing]. Okay, the historical development progress of developer A after submitting code to historical requirement K2 for the first time is calculated as follows: Then, based on the historical development progress after developer A first submitted code to historical requirement K1 and historical requirement K2. and The historical development progress of developer A after submitting code to the historical requirements for the first time can be calculated comprehensively. .

[0069] Similarly, R&D personnel B submitted the first request to historical requirement K1. The total number of code submissions from developer B in historical requirement K1 is [number missing]. Okay, calculate the historical development progress of developer B after submitting code to historical requirement K1 for the first time. Researcher B submitted the first version of the historical requirement K3. The total number of code submissions from developer B in historical requirement K3 is [number missing]. Okay, calculate the historical development progress of developer B after the first code submission to historical requirement K3. Based on the historical development progress after developer B first submitted code to historical requirement K1 and historical requirement K3. and The historical development progress of developer B after the first submission of code to the historical requirements was calculated as follows: .

[0070] This embodiment of the invention calculates the workload percentage of R&D personnel A and B based on the standard working hours of the first R&D personnel (R&D personnel A and R&D personnel B) in the target time data. Assuming that the standard working hours of R&D personnel A and R&D personnel B are 4 hours and 8 hours respectively, then the workload percentage of R&D personnel A is... The workload of R&D personnel B accounts for 10% of the total workload. The workload percentage of R&D personnel A Historical development progress with developer A after the first code submission to historical requirements Multiplying these together yields the first intermediate development progress, i.e., the first intermediate development progress. The workload percentage of R&D personnel B Historical development progress with developer B after the first code submission to historical requirements. Multiplying them together gives the second intermediate development progress, i.e., the second intermediate development progress. Finally, the first intermediate development progress will be announced. Second intermediate development progress Adding them together, we get the code development progress after the first developer (developer A and developer B) submits the code for the target requirement. .

[0071] Understandably, when it is detected that the first R&D personnel submitted code for the target requirement at other time points, the above calculation method can also be referenced. Based on the code reference data corresponding to historical requirements K1, K2 and K3, the code submission volume and total number of code submission candidates of R&D personnel A and R&D personnel B when submitting code at that time point can be calculated in combination with the target time data to calculate the code development progress of R&D personnel A and R&D personnel B after submitting code to the historical requirements at that time point.

[0072] This invention acquires target time data corresponding to the target requirement and historical code data that meets preset conditions. Specifically, it preprocesses the original historical code data based on a series of preset conditions according to two key dimensions: time relevance and consistency of development activity scale, to obtain accurate and reliable historical code data. Based on the historical code data, the developer's development mode can be determined. Due to the stability of individual developer behavior, the development progress of developers after submitting code at each time node can be calculated based on the historical code data and target time data. The calculated development progress is then used as the code development progress of the target requirement. In this way, the code development progress of the target requirement is calculated automatically, accurately, and efficiently, enabling developers to manage the code development progress of the target requirement in a timely manner, ensuring that the development progress is not affected as much as possible, and improving the quality of software development.

[0073] Please see Figure 4 , Figure 4 The illustration shows a sub-process diagram of step S300 in the code development progress calculation method based on developer behavior patterns provided in some embodiments of the present invention.

[0074] like Figure 4 As shown, in some embodiments, the code development progress for the target requirement is calculated based on historical code data and target time data, specifically including but not limited to the following steps S310-S340:

[0075] S310: Calculate the first development progress of all second-level R&D personnel based on the code reference data corresponding to all historical requirements.

[0076] In this embodiment of the invention, the first development progress is the development progress corresponding to the amount of code submitted by the second R&D personnel at the corresponding number of code submissions, that is, the development progress of the second R&D personnel after each submission of code equal to the amount of code submitted.

[0077] Specifically, based on the code reference data corresponding to all historical requirements in the historical code data, the development progress (i.e., the first development progress) of each historical requirement is calculated after all second R&D personnel submit the corresponding number of codes for each historical requirement at each time node.

[0078] In some embodiments, the first development progress of all second R&D personnel is calculated based on the code reference data corresponding to all historical requirements, including but not limited to the following steps S311-S313:

[0079] S311: Based on the number of code submissions corresponding to the candidate developers in the candidate historical requirements and the amount of code submissions corresponding to the number of code submissions, calculate the candidate development progress and reference development progress of the candidate developers in the candidate historical requirements.

[0080] In this embodiment of the invention, a candidate historical requirement is any one of at least one historical requirement, and a candidate developer is any one of one or more second developers corresponding to the candidate historical requirement. The candidate development progress is the development progress after the candidate developer first submits code for the candidate historical requirement, and the reference development progress is the development progress when the candidate developer first submits code to a reference requirement. The reference requirement is a requirement different from the candidate historical requirement; that is, the reference development progress is the development progress when the candidate developer first submits code to any other requirement different from the candidate historical requirement.

[0081] Specifically, for candidate developers, based on the code data of the candidate historical requirements submitted by the candidate developers in the historical code data, the candidate development progress and reference development progress of the candidate developers in the candidate historical requirements are calculated.

[0082] For example, if a candidate historical requirement is historical requirement K1, then the candidate developers can be developer A or developer B corresponding to candidate historical requirement K1. Based on the code data submitted by developer A for the candidate historical requirement (i.e., the number of code submissions, the amount of code submitted each time, the total number of candidate code submissions, and the submission time), the candidate development progress and reference development progress for developer A in candidate historical requirement K1 are calculated. Similarly, based on the code data submitted by developer B for the candidate historical requirement (i.e., the number of code submissions, the amount of code submitted each time, the total number of candidate code submissions, and the submission time), the candidate development progress and reference development progress for developer B in candidate historical requirement K1 are calculated.

[0083] For example, after calculating the candidate development progress and reference development progress of all second R&D personnel in all historical requirements, the first reference progress of all second R&D personnel is calculated and summarized based on the candidate development progress and reference development progress of all second R&D personnel.

[0084] In some embodiments, based on the number of code commits corresponding to candidate developers in the candidate historical requirements and the amount of code commits corresponding to those commits, the candidate development progress and reference development progress of candidate developers in the candidate historical requirements are calculated, including but not limited to the following steps S3111-S3113:

[0085] S3111: Retrieve code submission data of candidate developers from the candidate historical requirements.

[0086] In this embodiment of the invention, the code submission data includes the total number of code submission candidates, the number of candidate code submissions, and the number of reference code submissions. The number of candidate code submissions is the amount of code submitted by a candidate developer when they first submit code to a candidate historical requirement. The number of reference code submissions is the amount of code already submitted to a candidate historical requirement when a candidate developer first submits code to a reference requirement; that is, the number of reference code submissions is the amount of code already submitted to a candidate historical requirement when a candidate developer first submits code to a requirement different from the candidate historical requirement. The total number of code submission candidates is the sum of the amount of code submitted by candidate developers to candidate historical requirements, i.e., the total amount of code submitted by candidate developers to candidate historical requirements.

[0087] Specifically, in this embodiment of the invention, code reference data of candidate developers is extracted from historical code data. Based on the code reference data of the candidate developers, code submission data of the candidate developers is obtained. For example, if the historical code data is shown in Table 1 above, and the candidate historical requirement is historical requirement K1, then the candidate developers are developer A or developer B corresponding to historical requirement K1. Code reference data of developer A and developer B in historical requirement K1 is extracted (i.e., the number of code submissions and the amount of code submitted per submission / the number of code submissions corresponding to the number of submissions, submission time, total number of candidate code submissions, etc.). Based on the code reference data of developer A and developer B, the code submission data of developer A and developer B is obtained, that is, the candidate code submission amount of developer A is obtained. The number of lines and reference code commits is The number of candidate code submissions by R&D personnel B is The number of lines and reference code commits is OK.

[0088] S3112: Divide the number of candidate code submissions by the total number of code submission candidates to obtain the candidate development progress of candidate developers.

[0089] Specifically, the candidate development progress of a candidate developer is obtained by dividing the number of candidate code submissions by the total number of candidate code submissions for that developer. For example, dividing developer A's number of candidate code submissions by the total number of candidate code submissions for developer A yields developer A's candidate development progress, i.e., developer A's candidate development progress. .

[0090] S3113: Divide the number of reference code submissions by the total number of code submission candidates to obtain the reference development progress of the candidate developers.

[0091] Specifically, the reference code submissions of candidate developers are divided by the total number of code submissions submitted by all candidate developers to obtain their reference development progress. For example, dividing developer A's reference code submissions by the total number of code submissions submitted by developer A yields developer A's reference development progress. .

[0092] For example, based on the historical code data shown in Table 1, the candidate development progress and reference development progress for all second R&D personnel are calculated as shown in Table 2 below:

[0093] Table 2:

[0094]

[0095] Based on Table 2 above, and in conjunction with the following embodiments of the present invention, the first and second comprehensive progress of candidate R&D personnel are calculated.

[0096] S312: Calculate the first comprehensive progress of candidate R&D personnel based on the candidate development progress of candidate R&D personnel in all historical requirements.

[0097] Specifically, the development progress of the same candidate R&D personnel in all historical requirements is mathematically calculated to obtain the first comprehensive progress of the candidate R&D personnel. For example, after removing the maximum and minimum values ​​from the candidate development progress of the same candidate R&D personnel in all historical requirements, the median of the candidate development progress of the same candidate R&D personnel after removing the maximum and minimum values ​​is selected as the first comprehensive progress of the candidate R&D personnel.

[0098] In some embodiments, the first comprehensive progress of candidate developers is calculated based on the candidate development progress of candidate developers in all historical requirements, specifically including but not limited to the following steps S3121-S3122:

[0099] S3121: Calculate the average of the candidate development progress of candidate R&D personnel in all historical requirements to obtain the first average.

[0100] S3122: Determine the first average as the first overall progress of the candidate R&D personnel.

[0101] In this embodiment of the invention, the candidate development progress of all candidate R&D personnel in all historical requirements is extracted, and the average of all candidate development progress corresponding to the candidate R&D personnel is calculated to obtain the first average. The first average is determined as the first comprehensive progress of the candidate R&D personnel.

[0102] S313: Calculate the second comprehensive progress of candidate developers based on the reference development progress of candidate developers in all historical requirements.

[0103] Specifically, the reference development progress of the same candidate R&D personnel across all historical requirements is mathematically calculated to obtain the candidate R&D personnel's second comprehensive progress. For example, after removing the maximum and minimum values ​​from the reference development progress of the same candidate R&D personnel across all historical requirements, the median of the reference development progress of the same candidate R&D personnel after removing the maximum and minimum values ​​is selected as the candidate R&D personnel's second comprehensive progress.

[0104] In some embodiments, a second comprehensive progress of the candidate developers is calculated based on the reference development progress of the candidate developers in all historical requirements, specifically including but not limited to the following steps S3131-S3132:

[0105] S3131: Calculate the average of the reference development progress of candidate R&D personnel in all historical requirements to obtain the second average.

[0106] S3132: Determine the second average as the second overall progress of the candidate R&D personnel.

[0107] In this embodiment of the invention, the reference development progress of all candidate R&D personnel in all historical requirements is extracted, and the average of all reference development progress corresponding to the candidate R&D personnel is calculated to obtain a second average. This second average is determined as the second comprehensive progress of the candidate R&D personnel. The first development progress includes both the first comprehensive progress and the second comprehensive progress.

[0108] Based on Table 2 above, and combined with the methods used in the above embodiments of the present invention to calculate the first and second comprehensive progress of candidate R&D personnel, the first and second comprehensive progress (i.e., the first development progress) of candidate R&D personnel are calculated as shown in Table 3 below:

[0109] Table 3:

[0110]

[0111] Understandably, the historical code data shown in Table 1 is only illustrative. Therefore, Tables 2 and 3, calculated based on the historical code data shown in Table 1, are also illustrative. In this embodiment of the invention, other suitable historical code data can also be obtained, and other suitable candidate development progress and reference development progress of R&D personnel can be calculated based on the historical code data, as well as the first development progress of the final R&D personnel can be calculated.

[0112] S320: Calculate the workload percentage of all first-level R&D personnel based on target time data.

[0113] For example, the standard working hours of all first-level R&D personnel in the target time data are used to calculate the workload percentage of all first-level R&D personnel.

[0114] For example, in some embodiments, the workload percentage of all first-level R&D personnel is calculated based on target time data, specifically including but not limited to the following steps S321-S323:

[0115] S321: Obtain the first working hours of front-end developers and the second working hours of back-end developers based on target time data.

[0116] S322: Count the number of front-end developers and the number of back-end developers.

[0117] In this embodiment, the first R&D personnel includes front-end R&D personnel and back-end R&D personnel. The first working hours are the standard working hours of the front-end R&D personnel, and the second working hours are the standard working hours of the back-end R&D personnel.

[0118] Specifically, based on the research and development type of the primary R&D personnel, the first working hours of front-end R&D personnel and the second working hours of back-end R&D personnel are extracted from the target time data. Based on the target time data, the number of first-time front-end R&D personnel and the number of second-time back-end R&D personnel among all primary R&D personnel involved in solving the target requirement are calculated.

[0119] S323: Calculate the workload percentage of all front-end developers and all back-end developers based on the first working hour, the second working hour, the first quantity, and the second quantity.

[0120] Specifically, based on the first working hours and first number of front-end developers, and the second working hours and second number of back-end developers, the workload percentage of each front-end developer and the workload percentage of each back-end developer are calculated to obtain the workload percentage of all front-end developers and all back-end developers.

[0121] In some embodiments, the workload percentage of all front-end developers and all back-end developers is calculated based on the first working hours, the second working hours, the first quantity, and the second quantity, specifically including but not limited to the following steps S3231-S3235:

[0122] S3231: Add the first working hours and the second working hours together to get the total working hours.

[0123] S3232: Divide the first working hour by the total working hours to obtain the first percentage of the total.

[0124] S3233: Divide the second working hour by the total working hours to obtain the second percentage total.

[0125] S3234: Divide the sum of the first percentages by the first quantity to get the workload percentage of each front-end developer.

[0126] S3235: Divide the sum of the second percentages by the second quantity to obtain the workload percentage of each backend R&D personnel.

[0127] For example, the target time data is shown in Table 4 below:

[0128] Table 4:

[0129]

[0130] According to Table 4, the first working hours for front-end developers are 4 hours, and the second working hours for back-end developers are 8 hours. There is one front-end developer (developer C) and two back-end developers (developers A and B). Adding the first and second working hours together gives the total working hours. Hours. Divide the first working hour by the total working hours to obtain the first percentage sum, that is, the first percentage sum is... Dividing the second working hour by the total working hours yields the second percentage sum, which is: Dividing the sum of the first percentages by the first quantity gives the workload percentage of each front-end developer, i.e., the workload percentage of each front-end developer is... And by dividing the sum of the second percentages by the second quantity, we obtain the workload percentage of each backend developer, that is, the workload percentage of each backend developer is... .

[0131] It is understood that the target time data shown in Table 4 is only illustrative. The embodiments of the present invention can also obtain target time data corresponding to any other suitable target requirements, and the embodiments of the present invention do not impose any limitations on this.

[0132] S330: Select the first development progress of all first R&D personnel from the first development progress of all second R&D personnel.

[0133] In this embodiment of the invention, based on the target time data of all first R&D personnel involved in solving the target requirements, the first development progress of all first R&D personnel is selected from the first development progress of all second R&D personnel.

[0134] For example, please refer to Table 3. The first R&D personnel involved in solving the target requirements include R&D personnel A, B and C. Then, the first development progress of R&D personnel A, R&D personnel B and R&D personnel C are selected from the first development progress of all the second R&D personnel. That is, the first and second comprehensive progress of R&D personnel A, the first and second comprehensive progress of R&D personnel B and the first and second comprehensive progress of R&D personnel C.

[0135] S340: Calculate code development progress based on the first development progress and workload percentage of all first R&D personnel.

[0136] For example, the initial development progress of each first R&D personnel is multiplied by the proportion of their workload to obtain their intermediate development progress. The intermediate development progress of all first R&D personnel is then added together to obtain the code development progress of the target requirement.

[0137] For example, in some embodiments, the code development progress is calculated based on the first development progress and workload percentage of all first R&D personnel, specifically including but not limited to the following steps S341-S342:

[0138] S341: Multiply the first development progress of each first R&D personnel by the proportion of their workload to obtain the intermediate development progress of each first R&D personnel.

[0139] S342: Add up the intermediate development progress of all first-level R&D personnel to obtain the code development progress of the target requirements.

[0140] For example, please refer to Table 3. The first R&D personnel involved in solving the target requirement include R&D personnel A, B, and C. Multiplying R&D personnel A's initial development progress by R&D personnel A's workload percentage yields R&D personnel A's intermediate development progress. Multiplying R&D personnel B's initial development progress by R&D personnel B's workload percentage yields R&D personnel B's intermediate development progress. Multiplying R&D personnel C's initial development progress by R&D personnel C's workload percentage yields R&D personnel C's intermediate development progress.

[0141] That is, when the first development progress is the first integration progress, the first integration progress of R&D personnel A will be... Workload percentage of R&D personnel A Multiply by the product to obtain the intermediate development progress of developer A. The first comprehensive progress of R&D personnel B. Workload percentage of R&D personnel B Multiply by the product to obtain the intermediate development progress of developer B. The first comprehensive progress of R&D personnel C. Workload percentage of R&D personnel C Multiply by this to obtain the intermediate development progress of developer C. .

[0142] Similarly, when the first development progress is the second integration progress, the intermediate development progress of R&D personnel A is calculated. Intermediate development progress of R&D personnel B Intermediate development progress with R&D personnel C .

[0143] Finally, the intermediate development progress of developer A, developer B, and developer C are added together to obtain the code development progress for the target requirements. For example, when the first development progress is the first integration progress, developer A's intermediate development progress is added together. Intermediate development progress of R&D personnel B Intermediate development progress with R&D personnel C Add them together to get the code development progress for the target requirements. .

[0144] Please see Figure 5 , Figure 5 This illustration shows another sub-process diagram of step S300 in the code development progress calculation method based on developer behavior patterns provided in some embodiments of the present invention.

[0145] like Figure 5 As shown, in some embodiments, the code development progress for the target requirements is calculated based on historical code data and target time data, specifically including but not limited to the following step S350:

[0146] S350: The response indicates that the self-test case for the target requirement has been successfully executed, and the preset reference progress value is determined to be the code development progress of the target requirement.

[0147] Specifically, after the first R&D personnel completes all the code for the target requirement, they need to self-test the developed code, that is, execute the self-test cases for the target requirement to test the code. When the execution of the self-test cases for the target requirement is detected as successful, it means that the first R&D personnel has completed and submitted all the code for the target requirement, and the preset reference progress value will be set. The code development progress for the target requirement has been determined, meaning that all code for the target requirement has been developed.

[0148] Passing the self-test test cases generally signifies the end of the initial development phase and the transition to the testing phase. The code development progress for the target requirements... The specific progress nodes are determined directly based on special events (i.e., the self-test case passes execution). In the code development progress calculation method based on developer behavior patterns provided in this embodiment of the invention, the actual progress will not reach... The code development progress.

[0149] The code development progress described in the embodiments of this invention is actually based on historical code data to predict the current development behavior / progress of developers. It should not be interpreted as the strict current development progress. The predicted development behavior / progress is provided as a reference for developers and project managers, so that the development progress can be adjusted in a timely manner according to the provided predicted development progress data.

[0150] In summary, this embodiment of the invention obtains target time data corresponding to the target requirement and historical code data that meets preset conditions. Specifically, it preprocesses the original historical code data based on a series of preset conditions according to two key dimensions: time relevance and consistency of development activity scale, to obtain accurate and reliable historical code data. Based on the historical code data, the developer's development mode can be determined. Due to the stability of individual developer behavior, the development progress of developers after submitting code at each time node can be calculated based on the historical code data and target time data. The calculated development progress is then used as the code development progress of the target requirement. In this way, the code development progress of the target requirement is calculated automatically, accurately, and efficiently, enabling developers to manage the code development progress of the target requirement in a timely manner, ensuring that the development progress is not affected as much as possible, and improving the quality of software development.

[0151] Those skilled in the art will understand that the embodiments provided by this invention are merely illustrative. The order in which the steps in the methods of the embodiments are written does not imply a strict execution order and does not constitute any limitation on the implementation process. The order can be adjusted, merged, and deleted according to actual needs. Modules or sub-modules, units or sub-units in the apparatus or system of the embodiments can be merged, divided, and deleted according to actual needs. For example, the division of units is only a logical functional division, and there may be other division methods in actual implementation. For another example, multiple units or components can be combined or integrated into another device, or some features can be ignored or not executed.

[0152] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented using software plus a general-purpose hardware platform, or of course, it can be implemented using hardware. Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. This computer program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods.

[0153] It should be noted that the above embodiments are for illustrating the technical concept and features of the present invention, and are intended to enable those skilled in the art to understand the content of the present invention and implement it accordingly. They should not be construed as limiting the scope of protection of the present invention. Those skilled in the art can understand that all or part of the processes of the above embodiments can be implemented by modifying the technical solutions described in the embodiments of the present invention, or by making equivalent substitutions for some of the technical features. It is understood that these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention, and should be considered as equivalent changes and modifications made based on the embodiments of the present invention, all of which should fall within the scope of the claims of the present invention.

Claims

1. A method for calculating code development progress based on developer behavior patterns, characterized in that, include: Obtain target time data corresponding to the target requirement, wherein the target time data includes the standard working hours and target submission time of one or more first R&D personnel, and the target submission time is the time when the first R&D personnel first submits code to the target requirement; Historical code data is obtained, which includes at least one historical requirement and code reference data corresponding to the historical requirement. The code reference data includes the total amount of code submitted by one or more second developers within a first historical time period, the number of code submissions, and the amount of code submissions and submission time corresponding to the number of code submissions. The total amount of code submissions is the sum of the amount of code submitted to the historical requirement by all second developers. The total amount of code submissions is greater than or equal to a first quantity threshold and less than or equal to a second quantity threshold. The length of the first historical time period is less than or equal to a first time length, and the difference in duration between the last submission time and the target submission time within the first historical time period is less than or equal to a second time length. The last submission time is the time when the second developer last submitted code to the historical requirement. The first developer is one of one or more second developers. Based on the historical code data and the target time data, the code development progress for the target requirement is calculated.

2. The method according to claim 1, characterized in that, The step of calculating the code development progress for the target requirement based on the historical code data and the target time data includes: Based on the code reference data corresponding to all the historical requirements, calculate the first development progress of all the second R&D personnel. The first development progress is the development progress of the second R&D personnel after submitting the code amount of code in the number of code submissions. Based on the target time data, calculate the workload percentage of all the first R&D personnel; Select the first development progress of all the first R&D personnel from the first development progress of all the second R&D personnel; The code development progress is calculated based on the first development progress and workload percentage of all the first R&D personnel. or, If the self-test case for the target requirement is detected to have passed execution, a preset reference progress value is determined to be the code development progress for the target requirement.

3. The method according to claim 2, characterized in that, The calculation of the first development progress for all second-level R&D personnel based on the code reference data corresponding to all the historical requirements includes: Based on the number of code submissions corresponding to candidate developers in the candidate historical requirements and the amount of code submissions corresponding to those submissions, the candidate development progress and reference development progress of the candidate developers in the candidate historical requirements are calculated. Here, the candidate historical requirements are any one of at least one of the historical requirements, the candidate developers are any one of one or more second developers corresponding to the candidate historical requirements, the candidate development progress is the development progress after the candidate developers first submit the code for the candidate historical requirements, and the reference development progress is the development progress when the candidate developers first submit the code to the reference requirements, where the reference requirements are requirements different from the candidate historical requirements. Based on the candidate development progress of the candidate R&D personnel in all the historical requirements, the first comprehensive progress of the candidate R&D personnel is calculated; Based on the reference development progress of the candidate R&D personnel in all the historical requirements, the second comprehensive progress of the candidate R&D personnel is calculated, and the first development progress includes the first comprehensive progress and the second comprehensive progress.

4. The method according to claim 3, characterized in that, The step of calculating the candidate development progress and reference development progress of the candidate developers in the candidate historical requirements based on the number of code commits corresponding to the candidate developers in the candidate historical requirements and the amount of code commits corresponding to the number of code commits includes: Obtain the code submission data of the candidate developers in the candidate historical requirements. The code submission data includes the total number of code submission candidates, the number of candidate code submissions, and the number of reference code submissions. The number of candidate code submissions is the amount of code submitted by the candidate developer when they first submitted code to the candidate historical requirements. The number of reference code submissions is the amount of code that the candidate developer had already submitted to the candidate historical requirements when they first submitted code to the reference requirements. The total number of code submission candidates is the sum of the amount of code submitted by the candidate developers to the candidate historical requirements. Divide the number of candidate code submissions by the total number of candidate code submissions to obtain the candidate development progress of the candidate developers; Divide the reference code submissions by the total number of code submission candidates to obtain the reference development progress of the candidate developers.

5. The method according to claim 3, characterized in that, The step of calculating the first comprehensive progress of the candidate R&D personnel based on their candidate development progress in all historical requirements includes: The average development progress of the candidate R&D personnel in all the historical requirements is calculated to obtain the first average. The first average value is determined to be the first overall progress of the candidate R&D personnel.

6. The method according to claim 3, characterized in that, The step of calculating the second comprehensive progress of the candidate R&D personnel based on the reference development progress of all the candidate R&D personnel in the historical requirements includes: The average of the reference development progress of the candidate R&D personnel in all the historical requirements is used to obtain the second average. The second mean is determined to be the second overall progress of the candidate R&D personnel.

7. The method according to any one of claims 2-6, characterized in that, The first R&D personnel include front-end R&D personnel and back-end R&D personnel. The calculation of the workload percentage of all first R&D personnel based on the target time data includes: Based on the target time data, the first working hours of the front-end developers and the second working hours of the back-end developers are obtained, wherein the first working hours are the standard working hours of the front-end developers and the second working hours are the standard working hours of the back-end developers; Calculate the first number of front-end developers and the second number of back-end developers; Based on the first working hours, the second working hours, the first quantity, and the second quantity, calculate the workload ratio of all front-end developers and all back-end developers.

8. The method according to claim 7, characterized in that, The calculation of the workload percentage for all front-end developers and all back-end developers based on the first working hours, the second working hours, the first quantity, and the second quantity includes: Add the first working hours and the second working hours to get the total working hours; Divide the first working hour by the total working hours to obtain the first percentage sum; Divide the second working hours by the total working hours to obtain the second percentage total; Divide the sum of the first percentages by the first quantity to obtain the workload percentage of each front-end developer. Divide the sum of the second percentages by the second quantity to obtain the workload percentage of each backend R&D personnel.

9. The method according to claim 7, characterized in that, The calculation of the code development progress based on the first development progress and workload percentage of all the first R&D personnel includes: Multiply the first development progress of each first R&D personnel by the proportion of their workload to obtain the intermediate development progress of each first R&D personnel. The intermediate development progress of all the first R&D personnel is added together to obtain the code development progress of the target requirement.

10. An electronic device, characterized in that, include: A processor and a memory communicatively connected to the processor; The memory stores computer program instructions executable by the processor, which, when executed by the processor, cause the electronic device to perform the code development progress calculation method based on developer behavior patterns as described in any one of claims 1-9.

Images