Agile development-oriented requirement change tracking and management optimization method and system

Abstract

The application provides a requirement change tracking and management optimization method and system for agile development, relates to the technical field of agile development requirement management, and comprises the following steps: constructing a task dependency tracking graph and embedding a change influence path mode as a propagation weight correction factor, performing bidirectional path tracking on a change request to determine a set of affected tasks, identifying and quantifying resource conflicts, constructing a priority constraint graph based on task dependency depth and combining a resource conflict management list to establish resource allocation constraints, thereby generating a task reordering and resource reallocation scheme, and improving the tracking accuracy and management efficiency of requirement changes in an agile development environment.

Description

Technical Field

[0001] This invention relates to the field of agile development requirements management technology, and in particular to a method and system for tracking and managing requirements changes in agile development. Background Technology

[0002] With the evolution of software development methodologies, Agile development has become the mainstream development model in the field of software engineering. Agile development emphasizes iterative development, continuous delivery, and rapid response to changes, enabling teams to adapt more flexibly to changing requirements. In an Agile environment, requirement changes are the norm, not the exception; project teams need to continuously receive, evaluate, and integrate new requirement change requests. These changes originate from market feedback, adjustments in user requirements, or changes in the technological environment, and have a profound impact on the development process.

[0003] Existing technologies for managing requirements changes in agile environments lack a systematic task dependency tracking mechanism. Current methods rely heavily on manual experience to determine dependencies between tasks, making it difficult to construct a complete dependency network, especially in large projects. This leads to incomplete change impact analysis, easily overlooking indirectly related tasks and causing rework and schedule delays. Resource conflict prediction and management capabilities are insufficient. When requirement changes are introduced, multiple tasks compete for the same development resources, and existing technologies lack effective mechanisms to identify these potential conflict points and quantify their severity. Teams often react reactively only after conflicts occur, impacting development efficiency and project schedule. There is a lack of adaptive task reordering and resource reallocation mechanisms. Faced with requirement changes, existing methods typically use fixed priority rules for task adjustments, failing to dynamically adjust task order and resource allocation based on specific changes. This prevents optimal resource utilization and reduces the agile team's adaptability and response efficiency to changes. Summary of the Invention

[0004] This invention provides a method and system for tracking and managing requirements changes in agile development, which can solve the problems in the prior art.

[0005] A first aspect of this invention provides a method for optimizing requirement change tracking and management in agile development, comprising:

[0006] Based on the requirement change requests of agile development, multi-dimensional dependency analysis is performed on agile development task objects to construct a task dependency tracking graph; pattern mining is performed on historical requirement change tracking records to extract recurring change impact path patterns as propagation weight correction factors and embed them into the task dependency tracking graph.

[0007] Based on the task dependency tracing graph, the bidirectional propagation path of the requirement change request is traced, and the set of tasks directly and indirectly affected by the requirement change request is determined by combining the propagation weight correction factor.

[0008] Based on the execution time window and resource occupancy status of the task set, identify resource conflict points caused by the requirement change request, and perform a quantitative assessment of the conflict severity of the resource conflict points to obtain a resource conflict management list.

[0009] A task priority constraint graph is constructed based on the dependency depth of the task set, and resource allocation constraints are established according to the task priority constraint graph and the resource conflict management list.

[0010] Based on the dependency depth between the resource conflict management list and the task set, the execution order and resource allocation scheme of the agile development task objects are jointly solved through the resource allocation constraints to generate a reordering scheme and a resource reallocation scheme, thereby obtaining management optimization results.

[0011] Based on agile development requirement change requests, multi-dimensional dependency analysis is performed on agile development task objects to construct a task dependency tracing graph, including:

[0012] Extract the code module identifiers and interface call relationships involved in the change request, identify the functional dependencies of the agile development task objects, and determine the dependency links between the agile development task objects caused by functional calls.

[0013] The data input / output specifications corresponding to the agile development task objects are parsed, and data flow dependencies are established by matching the data output ports and data input ports between the agile development task objects to form a data transmission dependency path.

[0014] Extract the execution preconditions and completion status constraints of the agile development task object, and construct a temporal constraint relationship;

[0015] A consistency check is performed on the dependency links, the data transmission dependency paths, and the timing constraints to obtain the dependency conflict assessment results.

[0016] Based on the dependency conflict assessment results, the conflicting dependencies are prioritized, and the functional dependencies, data flow dependencies, and temporal constraints are resolved according to the priority ranking results. A set of resolved dependencies is generated and fused and mapped to generate the task dependency tracking graph.

[0017] Pattern mining is performed on historical requirement change tracking records to extract recurring change impact path patterns as propagation weight correction factors, which are then embedded into the task dependency tracking graph.

[0018] Extract requirement change identifiers, affected task identifiers, and inter-task dependency propagation paths from the historical requirement change tracking records to construct a sample set of historical change impact paths.

[0019] The path structure similarity of the inter-task dependency propagation paths in the historical change impact path sample set is calculated to identify path structure patterns that occur more frequently than a preset frequency threshold, thereby obtaining a set of repeated path structure patterns.

[0020] The number of times each path structure pattern in the set of repeated path structure patterns appears and the number of tasks affected are counted in the set of historical change-affected paths. The influence propagation intensity value of the path structure pattern is calculated based on the number of occurrences and the number of tasks affected.

[0021] The normalized value of the influence propagation intensity is used as the propagation weight correction factor. The path node sequence and dependency type sequence of the path structure pattern are used as index keys, and the propagation weight correction factor is used as index value to establish an association mapping relationship.

[0022] In the task dependency tracing graph, identify dependency propagation sub-paths that match the path structure patterns in the set of repeating path structure patterns;

[0023] Based on the association mapping relationship, the propagation weight correction factor corresponding to the dependency propagation sub-path is embedded into the corresponding dependency relationship edge in the task dependency tracking graph, thereby completing the integration of the propagation weight correction factor into the task dependency tracking graph.

[0024] Based on the task dependency tracing graph, the bidirectional propagation path of the requirement change request is traced, and the set of tasks directly and indirectly affected by the requirement change request is determined by combining the propagation weight correction factor, including:

[0025] Extract the change trigger task identifier from the requirement change request, and locate the initial task node corresponding to the change trigger task identifier in the task dependency tracking graph;

[0026] Starting from the initial task node, a graph traversal operation is performed based on the directional identifier of the dependency relationship edge in the task dependency tracking graph, and the traversed task nodes are divided into multiple propagation levels according to the dependency level depth.

[0027] Extract the propagation path between the task node within the propagation layer and the initial task node, obtain the corresponding propagation weight correction factor from the dependency edges on the propagation path, and perform path decay accumulation calculation to obtain the path propagation decay coefficient of the propagation path.

[0028] The path propagation attenuation coefficients corresponding to multiple propagation paths are fused and aggregated to obtain the comprehensive impact attenuation coefficient of the task node; the comprehensive impact attenuation coefficient is combined with the propagation level depth to obtain the impact metric.

[0029] Task nodes whose impact metric exceeds a preset direct impact threshold are classified as directly impacted tasks, and task nodes whose impact metric is between the preset direct impact threshold and the preset indirect impact threshold are classified as indirectly impacted tasks; the directly impacted tasks and the indirect impacted tasks are merged to obtain the task set.

[0030] Based on the execution time window and resource occupancy status of the task set, identify resource conflict points caused by the requirement change request, and perform a quantitative assessment of the conflict severity of the resource conflict points, including:

[0031] Using resource type identifiers as row indexes and time scales as column indexes, and recording the resource usage quantity of each resource type identifier at each time scale as the resource usage status, a resource time axis usage matrix is ​​constructed.

[0032] Traverse the task nodes in the task set, map the execution time window of the task node to the time scale range of the resource time axis occupancy matrix, and accumulate the resource requirement of the task node to the corresponding matrix cell in the resource time axis occupancy matrix;

[0033] When the resource usage of the matrix unit exceeds the preset resource capacity limit, the resource type identifier, time scale, and excess quantity corresponding to the matrix unit are marked as resource conflict points.

[0034] Extract the time scale corresponding to the resource conflict point, and retrieve the task nodes whose execution time window covers the time scale in the task set to construct the conflict task node set of the resource conflict point;

[0035] Extract the priority level information and resource requirement quantity of the task nodes from the set of conflicting task nodes, and calculate the priority level difference and resource requirement competition degree of the task nodes in the set of conflicting task nodes.

[0036] The number of resource conflict points exceeding the limit, the priority level difference, and the resource demand competition degree are combined to obtain a quantitative score of the conflict severity of the resource conflict points.

[0037] Based on the dependency depth of the task set, a task priority constraint graph is constructed, and resource allocation constraints are established according to the task priority constraint graph and the resource conflict management list, including:

[0038] Recursively perform depth-first traversal along the dependency relationship edges in the task dependency tracking graph, and calculate the length of the longest dependency path from the initial task node to the task node for each task node as the dependency depth value of the task node. Task nodes with the same dependency depth value are grouped into the same priority level.

[0039] Within the priority hierarchy, constraints are established based on the dependency relationships between task nodes; between different priority levels, constraints are established based on the magnitude of the dependency depth values; the constraints within the priority hierarchy and the constraints between the priority levels are merged to construct the task priority constraint graph.

[0040] Extract resource identifiers, resource capacity limits, and resource occupancy time windows from the resource conflict management list; traverse the task nodes in the task priority constraint graph and extract the resource requirement identifiers and resource requirement time windows of the task nodes;

[0041] The resource requirement identifier is matched and associated with the resource identifier. If the resource capacity limit does not meet the resource requirement of the task node, the priority order of resource allocation is determined based on the priority hierarchy relationship in the task priority constraint graph. Time conflict detection is performed by combining the resource requirement time window and the resource occupation time window to obtain the resource allocation constraint rule.

[0042] Based on the dependency depth between the resource conflict management list and the task set, the execution order and resource allocation scheme of the agile development task objects are jointly solved through the resource allocation constraints to generate a reordering scheme and a resource reallocation scheme, resulting in management optimization results including:

[0043] Based on the conflict severity metric score, resource conflict points are prioritized, and a set of conflict task nodes corresponding to the highest priority resource conflict points is extracted. Then, task nodes with smaller dependency depth values ​​are identified from the set of conflict task nodes as adjustable task nodes.

[0044] The execution time window of the adjustable task node is matched with the resource capacity limit in the resource allocation constraint, an available time period that meets the resource capacity limit is searched, the execution time window of the adjustable task node is adjusted to the available time period, and a time adjustment operation is generated.

[0045] For task nodes whose conflicts cannot be eliminated by time adjustment, based on the resource allocation priority in the resource allocation constraints, the resource allocation of task nodes with resource allocation weights higher than the preset weight threshold is maintained with the original resource allocation amount, and the resource allocation of task nodes with resource allocation weights lower than the preset weight threshold is reduced, generating a resource reduction operation.

[0046] Summarize the adjusted execution time windows from the time adjustment operations to construct a reordering scheme; summarize the adjusted resource allocation amounts from the resource reduction operations to construct a resource reallocation scheme.

[0047] The reordering scheme and the resource reallocation scheme are applied to the agile development task object to obtain the management optimization result.

[0048] A second aspect of the present invention provides a requirement change tracking and management optimization system for agile development, comprising:

[0049] The first unit is used to perform multi-dimensional dependency analysis on agile development task objects based on agile development requirement change requests, and construct a task dependency tracking graph; it also performs pattern mining on historical requirement change tracking records, extracts recurring change impact path patterns as propagation weight correction factors, and embeds them into the task dependency tracking graph.

[0050] The second unit is used to perform bidirectional propagation path tracing of the requirement change request based on the task dependency tracing graph, and to determine the set of tasks directly and indirectly affected by the requirement change request in combination with the propagation weight correction factor.

[0051] The third unit is used to identify resource conflict points caused by the requirement change request based on the execution time window and resource occupancy status of the task set, and to perform a quantitative assessment of the conflict severity of the resource conflict points to obtain a resource conflict management list.

[0052] The fourth unit is used to construct a task priority constraint graph based on the dependency depth of the task set, and to establish resource allocation constraints according to the task priority constraint graph and the resource conflict management list.

[0053] The fifth unit is used to jointly solve the execution order and resource allocation scheme of the agile development task objects based on the dependency depth of the resource conflict management list and the task set, through the resource allocation constraints, to generate a reordering scheme and a resource reallocation scheme, and obtain management optimization results.

[0054] A third aspect of the present invention,

[0055] An electronic device is provided, comprising:

[0056] processor;

[0057] Memory used to store processor-executable instructions;

[0058] The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0059] Fourth aspect of the present invention,

[0060] A computer-readable storage medium is provided, having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0061] The beneficial effects of this application are as follows:

[0062] By constructing a task dependency tracking graph and integrating historical change patterns as propagation weight correction factors, the system can accurately identify the sets of tasks directly and indirectly affected, avoiding the problem of inaccurate judgment of the scope of change impact in traditional methods. Based on task execution time windows and resource occupancy status, the system performs a quantifiable assessment of resource conflict points caused by requirement changes, forming a structured conflict management list, which improves the scientific nature and visualization of resource conflict management. By constructing a priority constraint graph through task dependency depth and combining it with the resource conflict management list to form resource allocation constraints, the system provides a theoretical basis for task reordering and solves the problem of the lack of systematic task priority adjustment in traditional methods. Attached Figure Description

[0063] Figure 1 This is a flowchart illustrating the requirement change tracking and management optimization method for agile development according to an embodiment of the present invention;

[0064] Figure 2 A schematic diagram of the process for building a task dependency tracing graph. Detailed Implementation

[0065] 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. 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.

[0066] The technical solution of the present invention will be described in detail below with reference to specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments.

[0067] Figure 1This is a flowchart illustrating the requirement change tracking and management optimization method for agile development according to an embodiment of the present invention, as shown below. Figure 1 As shown, the method includes:

[0068] Based on the requirement change requests of agile development, multi-dimensional dependency analysis is performed on agile development task objects to construct a task dependency tracking graph; pattern mining is performed on historical requirement change tracking records to extract recurring change impact path patterns as propagation weight correction factors and embed them into the task dependency tracking graph.

[0069] Based on the task dependency tracing graph, the bidirectional propagation path of the requirement change request is traced, and the set of tasks directly and indirectly affected by the requirement change request is determined by combining the propagation weight correction factor.

[0070] Based on the execution time window and resource occupancy status of the task set, identify resource conflict points caused by the requirement change request, and perform a quantitative assessment of the conflict severity of the resource conflict points to obtain a resource conflict management list.

[0071] A task priority constraint graph is constructed based on the dependency depth of the task set, and resource allocation constraints are established according to the task priority constraint graph and the resource conflict management list.

[0072] Based on the dependency depth between the resource conflict management list and the task set, the execution order and resource allocation scheme of the agile development task objects are jointly solved through the resource allocation constraints to generate a reordering scheme and a resource reallocation scheme, thereby obtaining management optimization results.

[0073] In one optional implementation, multi-dimensional dependency resolution is performed on agile development task objects based on agile development requirement change requests, and a task dependency tracing graph is constructed, including:

[0074] Extract the code module identifiers and interface call relationships involved in the change request, identify the functional dependencies of the agile development task objects, and determine the dependency links between the agile development task objects caused by functional calls.

[0075] The data input / output specifications corresponding to the agile development task objects are parsed, and data flow dependencies are established by matching the data output ports and data input ports between the agile development task objects to form a data transmission dependency path.

[0076] Extract the execution preconditions and completion status constraints of the agile development task object, and construct a temporal constraint relationship;

[0077] A consistency check is performed on the dependency links, the data transmission dependency paths, and the timing constraints to obtain the dependency conflict assessment results.

[0078] Based on the dependency conflict assessment results, the conflicting dependencies are prioritized, and the functional dependencies, data flow dependencies, and temporal constraints are resolved according to the priority ranking results. A set of resolved dependencies is generated and fused and mapped to generate the task dependency tracking graph.

[0079] like Figure 2 As shown, the method includes:

[0080] Based on agile development, the system handles requirement change requests by extracting the identifiers of the affected code modules and their API call relationships. Static code analysis is used to scan the codebase for modifications and identify the code modules impacted by the changes. For example, when receiving a change request to "add a new payment method to the payment module," regular expressions are used to match class names, method names, and interface definitions in the code to identify relevant modules such as "PaymentService" and "PaymentController." Simultaneously, code call chain analysis tools are used to parse the call relationships between methods, constructing a preliminary API call graph and recording call dependencies such as "OrderService calls PaymentService.process()."

[0081] The task management system is queried to obtain a list of task objects in the current iteration. Then, a matching degree is calculated based on the semantic similarity between the code module and the task description. Tasks with a relevance exceeding a preset threshold are considered related tasks. Functional dependencies between tasks are deduced based on interface call relationships, forming a dependency chain of "task A depends on task B". For example, if the OrderService in the "order confirmation task" calls the PaymentService in the "payment processing task", then a functional dependency relationship is established between the former and the latter.

[0082] Parsing the data input / output specifications corresponding to agile development task objects requires analyzing the parameter types and return values ​​of the task-related interfaces. This is done by scanning API documentation or code comments for markers such as `@param` and `@return` to extract the interface's input parameters and output data structures. Each task object is treated as a data processing unit, defining its set of data input ports and set of data output ports. By comparing the data types, structures, and semantics of data ports across different tasks, data flow dependencies are established. When the data output port of task A matches the data input port of task B, a data transfer dependency path from A to B is considered to exist. For example, if the output of the "User Registration Task" contains "User ID," and the input of the "User Information Supplement Task" requires "User ID," then a data dependency is formed.

[0083] Extracting the preconditions and completion constraints of agile development task objects is primarily based on the task description documents and task state definitions in agile development tools. Through keyword extraction techniques, phrases indicating preconditions, such as "must follow" or "depends on," are identified in the task descriptions to extract the preconditions for task execution. Simultaneously, descriptions of task "completion criteria" and "acceptance conditions" are analyzed to determine the task's completion constraints. These constraints are then transformed into formalized temporal condition expressions, constructing a temporal constraint relationship graph between tasks. For example, "the database migration task must be completed before the application deployment task" constitutes a temporal constraint.

[0084] Consistency checks are performed on dependency links, data transfer dependency paths, and timing constraints to detect any conflicts among these three types of dependencies. A comprehensive dependency matrix is ​​constructed, with rows and columns representing task objects, and matrix elements representing combinations of dependency types between corresponding tasks. Circular dependencies are checked using a depth-first search algorithm to detect cycles in the dependency graph. Timing conflicts are also checked; if task A precedes task B temporally, but B precedes A in terms of functional or data dependencies, this is marked as a conflict. The consistency between data flow and function call is checked; if the direction of data flow is inconsistent with the direction of function call, this is marked as a potential problem. All detected conflicts are recorded as dependency conflict evaluation results.

[0085] Conflicting dependencies are prioritized based on the dependency conflict assessment results, considering the following factors: conflict severity, task priority, task deadline urgency, and scope of impact of the change. A weighted scoring method is used to calculate a priority score for each conflicting dependency: P = w1·S + w2·T + w3·D + w4·I, where S is the severity, T is the task priority, D is the deadline urgency, I is the scope of impact, and w is the corresponding weight. Conflicting dependencies are then sorted in descending order based on the calculated priority scores.

[0086] Based on the priority ranking results, conflict resolution is performed on functional dependencies, data flow dependencies, and timing constraints. For high-priority circular dependencies, it is recommended to split tasks or introduce an intermediate layer to remove direct dependencies. For timing conflicts, the task execution order is adjusted to meet dependency requirements, or the requirements are modified to reduce coupling. For inconsistencies between data flow and function calls, the interface design can be refactored to ensure data flow aligns with the call direction. These strategies generate a set of resolved dependencies.

[0087] The three types of dependencies, after being resolved, are merged and mapped to generate a unified task dependency tracking graph. A directed graph structure is used to represent task dependencies, with nodes representing agile development task objects and edges representing dependencies. Edge attributes indicate the dependency type (functional dependency, data dependency, or temporal constraint) and dependency strength. Visualization techniques are employed to present the dependency graph, using different colors or line styles to distinguish different dependency types. This facilitates team understanding and tracking of complex dependencies between tasks, thereby better managing the impact of requirement changes on the development process.

[0088] In one optional implementation, pattern mining is performed on historical requirement change tracking records, and recurring change impact path patterns are extracted and embedded as propagation weight correction factors into the task dependency tracking graph, including:

[0089] Extract requirement change identifiers, affected task identifiers, and inter-task dependency propagation paths from the historical requirement change tracking records to construct a sample set of historical change impact paths.

[0090] The path structure similarity of the inter-task dependency propagation paths in the historical change impact path sample set is calculated to identify path structure patterns that occur more frequently than a preset frequency threshold, thereby obtaining a set of repeated path structure patterns.

[0091] The number of times each path structure pattern in the set of repeated path structure patterns appears and the number of tasks affected are counted in the set of historical change-affected paths. The influence propagation intensity value of the path structure pattern is calculated based on the number of occurrences and the number of tasks affected.

[0092] The normalized value of the influence propagation intensity is used as the propagation weight correction factor. The path node sequence and dependency type sequence of the path structure pattern are used as index keys, and the propagation weight correction factor is used as index value to establish an association mapping relationship.

[0093] In the task dependency tracing graph, identify dependency propagation sub-paths that match the path structure patterns in the set of repeating path structure patterns;

[0094] Based on the association mapping relationship, the propagation weight correction factor corresponding to the dependency propagation sub-path is embedded into the corresponding dependency relationship edge in the task dependency tracking graph, thereby completing the integration of the propagation weight correction factor into the task dependency tracking graph.

[0095] Essential information is extracted from historical requirement change tracking records to construct a sample set of historical change impact paths. Specifically, each historical change record is parsed to extract the requirement change identifier (e.g., "REQ-001"), the affected task identifiers (e.g., "TASK-A", "TASK-B"), and the dependency propagation path between tasks (e.g., "TASK-A→TASK-B→TASK-C"). This information is organized into structured data, with each record containing the change source, the affected target, and detailed propagation path information. For example, a record might be represented as: "The change caused by REQ-001 affected TASK-C through the path TASK-A→TASK-B→TASK-C." By processing a large number of historical records, a sample set containing diverse change impact paths is obtained.

[0096] Path structure similarity is calculated for inter-task dependency propagation paths in the historical change impact path sample set, based on the path's node sequence and edge type sequence. For example, for two paths "TASK-A (Development) → TASK-B (Testing) → TASK-C (Deployment)" and "TASK-D (Development) → TASK-E (Testing) → TASK-F (Deployment)," although the specific tasks are different, the path structure "Development → Testing → Deployment" is the same. Paths with similar structures can be identified by calculating the edit distance between paths or using graph pattern matching algorithms. When a path structure pattern appears more frequently in the historical record than a preset threshold (e.g., more than 10 times), it is added to the set of repeated path structure patterns.

[0097] For each identified path structure pattern, calculate its total occurrences in the historical change log and the total number of tasks affected by that path structure. Based on these two statistics, calculate the impact propagation strength value of that path structure pattern. The impact propagation strength value can be calculated as follows: multiply the number of occurrences of the path pattern by the number of tasks affected by that path, and then divide by the sum of such products for all path patterns. For example, if the "Development → Test → Deployment" path appears 15 times in the history and affects a total of 45 tasks, then the unnormalized impact propagation strength of this path is 15 × 45 = 675.

[0098] The calculated impact propagation strength values ​​are normalized to obtain propagation weight correction factors. Normalization ensures that the values ​​of all correction factors are within a reasonable range (e.g., between 0 and 2), which facilitates their application in the graph. The node sequence of the path structure pattern (e.g., "development → testing → deployment") and the dependency relationship type sequence (e.g., "prerequisite dependency → functional dependency") are used as composite index keys, and the corresponding normalized propagation weight correction factors are used as index values, stored in a key-value pair data structure.

[0099] In practical applications, dependency propagation sub-paths matching path structure patterns in a set of repeating path structure patterns are identified within the task dependency tracing graph. The task dependency tracing graph is a directed graph representing the dependencies between software development tasks, where nodes represent tasks and edges represent dependencies. By searching the graph for subgraph structures matching known path structure patterns, the locations where correction factors need to be applied can be identified. This process can be implemented using subgraph isomorphism algorithms or pattern matching algorithms.

[0100] Based on the previously established association mapping relationship, the propagation weight correction factor corresponding to the dependency propagation sub-path is embedded into the corresponding dependency relationship edge in the task dependency tracing graph. For example, when a path "TASK-X (development) → TASK-Y (testing) → TASK-Z (deployment)" is identified in the graph, if the correction factor for this structural pattern in the mapping relationship is 1.5, then the original propagation weight of the corresponding edge on that path is multiplied by 1.5 to obtain the corrected propagation weight value. This step is performed on all matching sub-paths in the graph, completing the process of integrating the propagation weight correction factor into the task dependency tracing graph.

[0101] Through the above steps, the impact propagation patterns that frequently occur in historical requirement changes are effectively extracted and quantified, and embedded as correction factors into the task dependency tracking graph. This allows the graph to more accurately reflect the propagation patterns of change impacts in actual projects, providing a more reliable foundation for subsequent change impact analysis.

[0102] In one optional implementation, the bidirectional propagation path of the requirement change request is traced based on the task dependency tracing graph, and the set of tasks directly and indirectly affected by the requirement change request is determined by combining the propagation weight correction factor, including:

[0103] Extract the change trigger task identifier from the requirement change request, and locate the initial task node corresponding to the change trigger task identifier in the task dependency tracking graph;

[0104] Starting from the initial task node, a graph traversal operation is performed based on the directional identifier of the dependency relationship edge in the task dependency tracking graph, and the traversed task nodes are divided into multiple propagation levels according to the dependency level depth.

[0105] Extract the propagation path between the task node within the propagation layer and the initial task node, obtain the corresponding propagation weight correction factor from the dependency edges on the propagation path, and perform path decay accumulation calculation to obtain the path propagation decay coefficient of the propagation path.

[0106] The path propagation attenuation coefficients corresponding to multiple propagation paths are fused and aggregated to obtain the comprehensive impact attenuation coefficient of the task node; the comprehensive impact attenuation coefficient is combined with the propagation level depth to obtain the impact metric.

[0107] Task nodes whose impact metric exceeds a preset direct impact threshold are classified as directly impacted tasks, and task nodes whose impact metric is between the preset direct impact threshold and the preset indirect impact threshold are classified as indirectly impacted tasks; the directly impacted tasks and the indirect impacted tasks are merged to obtain the task set.

[0108] The change request document is parsed to identify the task code or task description information it contains, and the triggering task identifier that serves as the source of the change is extracted. For example, when a change request to "modify the security verification mechanism of the user login module" is received, "user login module" can be extracted as the change triggering task identifier. Then, in a pre-built task dependency tracking graph, the initial task node identified as "T001-user login module" is located using a task identifier matching algorithm.

[0109] A breadth-first search algorithm is employed, starting from the initial task node and traversing both forward and backward. For forward dependencies, it explores which downstream tasks the initial task affects; for backward dependencies, it analyzes which upstream tasks influence changes to the initial task. During the traversal, all nodes are divided into different propagation levels based on the shortest path length from each node to the initial node. For example, task nodes directly connected to the initial task are classified as level one, tasks separated from the initial task by one node are classified as level two, and so on.

[0110] For each traversed task node, identify all paths between it and the initial task node. Each dependency edge on a path is assigned a propagation weight correction factor, representing the dependency strength. For example, a "strong dependency" has a weight correction factor of 0.9, and a "weak dependency" has a weight correction factor of 0.5. For a path containing multiple dependency edges, multiply the weight correction factors of all edges on the path to obtain the propagation attenuation coefficient of the path. For example, if a path has three edges with weight factors of 0.9, 0.8, and 0.7 respectively, then the propagation attenuation coefficient of the path is 0.9 × 0.8 × 0.7 = 0.504.

[0111] When multiple propagation paths exist from the initial task node to the target task node, the influence of these paths needs to be combined. A weighted average method is used to calculate the combined value of the propagation attenuation coefficients of all paths. Assuming there are n paths, and each path i has a propagation attenuation coefficient of ai and a corresponding weight of wi, the combined influence attenuation coefficient is calculated as ∑(ai×wi) / ∑wi. For example, if there are three paths with attenuation coefficients of 0.8, 0.6, and 0.5 respectively, and each with a weight of 1, then the combined influence attenuation coefficient is (0.8+0.6+0.5) / 3=0.633.

[0112] Using a weighted combination method, the impact metric is calculated as follows: α × overall impact attenuation coefficient + β × (1 / propagation level depth), where α and β are weighting coefficients, and α + β = 1. This calculation method considers both the attenuation of dependency intensity along the path and the distance between levels. For example, for a task node with an overall impact attenuation coefficient of 0.7 and a propagation level depth of 2, assuming α = 0.6 and β = 0.4, its impact metric is calculated as: 0.6 × 0.7 + 0.4 × (1 / 2) = 0.62.

[0113] Task nodes whose impact metric exceeds a preset direct impact threshold are classified as directly impacted tasks, while task nodes whose impact metric falls between the preset direct impact threshold and a preset indirect impact threshold are classified as indirectly impacted tasks. The direct impact threshold is set to 0.6, and the indirect impact threshold is set to 0.3. For task nodes with an impact metric of 0.62, since its value is greater than the direct impact threshold of 0.6, it is classified as a directly impacted task. For task nodes with an impact metric of 0.4, since its value is between 0.3 and 0.6, it is classified as an indirectly impacted task. Task nodes with an impact metric below 0.3 are considered unaffected.

[0114] All identified directly and indirectly impacted tasks are combined to form a complete set of affected tasks. This set can be further sorted or grouped according to attributes such as impact type (direct / indirect) and impact degree, providing a basis for subsequent change impact analysis and change management decisions. In a real-world application scenario, after analyzing a change request for the login module security mechanism in a software development project, five directly impacted tasks (such as user authentication, password management, and session control) and eight indirectly impacted tasks (such as user interface, access control, and logging) were identified, providing project managers with a comprehensive change impact assessment.

[0115] In one optional implementation, identifying resource conflict points caused by the requirement change request based on the execution time window and resource occupancy status of the task set, and performing a quantitative assessment of the conflict severity of the resource conflict points, includes:

[0116] Using resource type identifiers as row indexes and time scales as column indexes, and recording the resource usage quantity of each resource type identifier at each time scale as the resource usage status, a resource time axis usage matrix is ​​constructed.

[0117] Traverse the task nodes in the task set, map the execution time window of the task node to the time scale range of the resource time axis occupancy matrix, and accumulate the resource requirement of the task node to the corresponding matrix cell in the resource time axis occupancy matrix;

[0118] When the resource usage of the matrix unit exceeds the preset resource capacity limit, the resource type identifier, time scale, and excess quantity corresponding to the matrix unit are marked as resource conflict points.

[0119] Extract the time scale corresponding to the resource conflict point, and retrieve the task nodes whose execution time window covers the time scale in the task set to construct the conflict task node set of the resource conflict point;

[0120] Extract the priority level information and resource requirement quantity of the task nodes from the set of conflicting task nodes, and calculate the priority level difference and resource requirement competition degree of the task nodes in the set of conflicting task nodes.

[0121] The number of resource conflict points exceeding the limit, the priority level difference, and the resource demand competition degree are combined to obtain a quantitative score of the conflict severity of the resource conflict points.

[0122] A resource occupancy timeline matrix is ​​constructed. This matrix uses resource type identifiers as row indices and time scales as column indices. Each matrix cell records the resource occupancy quantity for a corresponding resource type at a specific time scale. For example, in a project management system, resource types include human resources (such as development engineers and test engineers), hardware resources (such as servers and network equipment), and software resources (such as licenses and storage space). The time scale is set according to the granularity of the project plan and can be in units such as hours, days, or weeks. Initially, all cells in the matrix are set to 0, indicating that the resource is not yet occupied.

[0123] Iterate through all task nodes in the task set. For each task node, extract its execution time window (start and end times) and resource requirement information (resource type and quantity). Map the execution time window of the task node to the time scale range of the resource time axis occupancy matrix, and accumulate the resource requirements of each type within this time window to the corresponding cell in the matrix. For example, if task A needs to use 2 development engineer resources within the time period [2023-01-01, 2023-01-05], then add 2 resource occupancy counts to the corresponding row of development engineers and the column cell corresponding to these 5 days in the matrix.

[0124] After accumulating the resource requirements for all task nodes, check the resource usage of each cell in the matrix. A pre-set resource capacity limit is established for each resource type. For example, the total number of development engineers is 10. When the resource usage of a cell in the matrix exceeds the preset capacity limit for that resource type, the corresponding resource type identifier, time scale, and the excess quantity (actual usage minus the capacity limit) are marked as a resource conflict point. For example, if on January 3, 2023, the demand for development engineers is 12, while the capacity limit is 10, then (Development Engineer, January 3, 2023, 2) is marked as a resource conflict point, indicating an excess of 2 people.

[0125] For each identified resource conflict point, its corresponding time scale is extracted, and all task nodes whose execution time window covers that time scale are retrieved from the task set to construct a set of conflicting task nodes for that resource conflict point. For example, for the resource conflict point (Development Engineer, 2023-01-03, 2), all task nodes that need to use the Development Engineer resource on 2023-01-03 are retrieved to form a set of conflicting task nodes.

[0126] Extract the priority level information and resource requirement of each task node from the set of conflicting task nodes, and calculate the priority level difference and resource requirement competition degree of the task nodes in the set. The priority level difference reflects the degree of imbalance in priorities among conflicting tasks, which can be measured by calculating the difference between the highest and lowest priority in the set. The resource requirement competition degree reflects the intensity of competition for resources among conflicting tasks, which can be measured by calculating the ratio of the total resource requirement of conflicting tasks to the available resource capacity.

[0127] The severity score of resource conflict points is obtained by combining the number of resource conflict points exceeding limits, the degree of difference in priority levels, and the degree of competition for resource demands. For example, a weighted summation method can be used: Conflict Severity = α × Number of Conflicts Exceeding Limits + β × Degree of Difference in Priority Levels + γ × Degree of Competition for Resource Demands, where α, β, and γ are weighting coefficients used to adjust the importance of each factor in the assessment. The weights can be adjusted according to the actual application scenario and needs. The higher the conflict severity score, the more serious the problem of the resource conflict point, and the more priority it needs to be resolved.

[0128] In practical applications, the resource conflict assessment results quantified using the above methods can help project managers identify potential risks in the project plan and develop targeted resource allocation strategies. For example, for periods with high conflict severity, increasing resource input, adjusting task priorities, or rescheduling task execution times can be considered to alleviate resource conflicts and ensure the smooth progress of the project.

[0129] In one optional implementation, constructing a task priority constraint graph based on the dependency depth of the task set, and establishing resource allocation constraints according to the task priority constraint graph and the resource conflict management list includes:

[0130] Recursively perform depth-first traversal along the dependency relationship edges in the task dependency tracking graph, and calculate the length of the longest dependency path from the initial task node to the task node for each task node as the dependency depth value of the task node. Task nodes with the same dependency depth value are grouped into the same priority level.

[0131] Within the priority hierarchy, constraints are established based on the dependency relationships between task nodes; between different priority levels, constraints are established based on the magnitude of the dependency depth values; the constraints within the priority hierarchy and the constraints between the priority levels are merged to construct the task priority constraint graph.

[0132] Extract resource identifiers, resource capacity limits, and resource occupancy time windows from the resource conflict management list; traverse the task nodes in the task priority constraint graph and extract the resource requirement identifiers and resource requirement time windows of the task nodes;

[0133] The resource requirement identifier is matched and associated with the resource identifier. If the resource capacity limit does not meet the resource requirement of the task node, the priority order of resource allocation is determined based on the priority hierarchy relationship in the task priority constraint graph. Time conflict detection is performed by combining the resource requirement time window and the resource occupation time window to obtain the resource allocation constraint rule.

[0134] Starting from the initial task node, each dependency edge is traversed, recording the path length from the initial node to the current node. For task nodes reachable by multiple paths, the length of the longest path is selected as the dependency depth value of that node. For example, for a dependency graph containing tasks A, B, C, D, and E, if A is the initial task, B and C depend on A, D depends on B and C, and E depends on D, then the dependency depth value of task A is 0, the dependency depth value of B and C is 1, the dependency depth value of D is 2, and the dependency depth value of E is 3. In this way, task nodes with the same dependency depth value are grouped into the same priority level, forming a hierarchical task structure.

[0135] Within a priority hierarchy, constraints are established based on the dependencies between task nodes. For task nodes within the same hierarchy, if a direct dependency exists, the execution priority of the dependent source task is higher than that of the dependent task. For example, in a hierarchy with a dependency depth of 1, if tasks B and C both exist but B depends on C, then C has a higher priority than B. This hierarchical constraint ensures the proper ordering of tasks at the same level.

[0136] Between different priority levels, constraints are established based on the magnitude of dependency depth values. Levels with smaller dependency depth values ​​have higher priority than those with larger dependency depth values. For example, a level with a dependency depth of 1 (such as tasks B and C) has higher priority than a level with a dependency depth of 2 (such as task D). These constraints ensure that tasks are executed in the order of their dependency depth.

[0137] By integrating the constraints within and between priority levels, a complete task priority constraint graph is constructed. This graph contains all task nodes and their priority relationships, forming a global constraint framework for task execution.

[0138] Extract resource identifiers, resource capacity limits, and resource occupancy time windows from the resource conflict management list. The resource identifier uniquely identifies each resource, the resource capacity limit indicates the maximum available amount of the resource, and the resource occupancy time window indicates the time period during which the resource has been occupied. For example, the capacity limit of computing resource R1 is 10 processing units, and the current occupancy time window is [10:00-11:30] and [14:00-15:30].

[0139] Traverse the task nodes in the task priority constraint graph and extract the resource requirement identifier and resource requirement time window for each node. The resource requirement identifier indicates the type of resource required by the task, and the resource requirement time window indicates the time period during which the task needs to occupy the resource. For example, task D needs to use resource R1, and the time window is [10:30-12:00].

[0140] The resource requirement identifier is matched and associated with the resource identifier to check whether the resource capacity meets the task requirements. If the resource capacity limit does not meet the resource requirements of the task node, the resource allocation priority needs to be determined based on the priority hierarchy in the task priority constraint graph. Tasks with higher priority have the right to be allocated resources first. At the same time, time conflict detection is performed by combining the resource requirement time window and the resource occupancy time window to determine whether there are resource conflicts caused by time overlap.

[0141] Time conflict detection is performed by comparing the start and end times of a time window. If the two time windows overlap and the total resource demand during the overlap period exceeds the resource capacity limit, a resource conflict is identified. In this case, based on the priority relationships in the task priority constraint diagram, various conflict resolution strategies can be adopted, such as delaying the execution time of low-priority tasks, splitting task execution, or finding alternative resources.

[0142] Through the above process, resource allocation constraints are ultimately obtained, which include task execution order, resource allocation schemes, and conflict resolution strategies. These constraints guide the system to allocate resources reasonably, ensuring that tasks are executed in the order of their dependencies while avoiding resource conflicts.

[0143] In practical applications, such as CI / CD pipeline task scheduling scenarios in software development projects, this method can effectively handle complex task dependencies and limited computing resource constraints, realize automated task scheduling and resource allocation, and improve resource utilization efficiency and task execution efficiency.

[0144] In one optional implementation, based on the dependency depth between the resource conflict management list and the task set, the execution order and resource allocation scheme of the agile development task objects are jointly solved through the resource allocation constraints to generate a reordering scheme and a resource reallocation scheme, resulting in management optimization results including:

[0145] Based on the conflict severity metric score, resource conflict points are prioritized, and a set of conflict task nodes corresponding to the highest priority resource conflict points is extracted. Then, task nodes with smaller dependency depth values ​​are identified from the set of conflict task nodes as adjustable task nodes.

[0146] The execution time window of the adjustable task node is matched with the resource capacity limit in the resource allocation constraint, an available time period that meets the resource capacity limit is searched, the execution time window of the adjustable task node is adjusted to the available time period, and a time adjustment operation is generated.

[0147] For task nodes whose conflicts cannot be eliminated by time adjustment, based on the resource allocation priority in the resource allocation constraints, the resource allocation of task nodes with resource allocation weights higher than the preset weight threshold is maintained with the original resource allocation amount, and the resource allocation of task nodes with resource allocation weights lower than the preset weight threshold is reduced, generating a resource reduction operation.

[0148] Summarize the adjusted execution time windows from the time adjustment operations to construct a reordering scheme; summarize the adjusted resource allocation amounts from the resource reduction operations to construct a resource reallocation scheme.

[0149] The reordering scheme and the resource reallocation scheme are applied to the agile development task object to obtain the management optimization result.

[0150] Resource conflict points are prioritized. The resource conflict management list contains multiple conflict points, each associated with multiple task nodes, and each conflict point has a corresponding severity metric score. Conflict points are sorted from highest to lowest score by reading these metric scores. For example, in an agile development project, there are three resource conflict points: a UI designer resource conflict (score 85), a backend developer resource conflict (score 72), and a tester resource conflict (score 63). After sorting by score from highest to lowest, the UI designer resource conflict is addressed first.

[0151] For the highest-priority resource conflict identified, the corresponding set of conflicting task nodes is extracted. For example, in a UI designer resource conflict, the involved task nodes include "User Login Interface Design," "Product List Page Design," and "Personal Center Interface Design." Next, task nodes with lower dependency depth values ​​are identified from the set of conflicting task nodes as adjustable task nodes. Dependency depth represents the depth of a task in the dependency graph. A lower dependency depth means that the task has less impact on other tasks, and adjusting its execution order or resource allocation will not cause serious chain reactions in the project. In the example above, assuming the dependency depth of "Personal Center Interface Design" is 1, while the dependency depths of the other two tasks are 3 and 4 respectively, then "Personal Center Interface Design" is identified as an adjustable task node.

[0152] The execution time window of adjustable task nodes is matched with the resource capacity limit in the resource allocation constraints. The resource capacity limit defines the available quantity of various resources in different time periods. During the execution time window matching process, the resource capacity data in the resource allocation constraints is retrieved to determine which time periods within the project cycle have remaining capacity for UI designer resources. For example, if the original plan was to execute the "Personal Center Interface Design" task in the second week, but the UI designer resources are already full in the second week, while there are available UI designer resources in the fourth week, then the execution time of the "Personal Center Interface Design" task will be adjusted to the fourth week, generating the corresponding time adjustment operation.

[0153] For task nodes whose conflicts cannot be resolved through time adjustments, resource allocation needs to be adjusted. Based on the resource allocation priority in the resource allocation constraints, task nodes are divided into high-priority and low-priority categories. Resource allocation weight is an indicator comprehensively evaluated based on factors such as the task's business value, urgency, and criticality. A preset weight threshold is set at 70 points. For task nodes with a resource allocation weight higher than 70 points, the original resource allocation remains unchanged; for task nodes with a resource allocation weight lower than 70 points, their resource allocation is appropriately reduced. For example, assuming the resource allocation weight for "Product List Page Design" is 65 points, lower than the preset weight threshold, and the original plan was to allocate 2 UI designers, it is now adjusted to 1 UI designer, generating the corresponding resource reduction operation.

[0154] The system summarizes the adjusted execution time windows from the time adjustment operations to construct a complete reordering scheme. This reordering scheme includes the adjusted execution time schedules for all task nodes, presented in the form of a Gantt chart or timetable. Simultaneously, it summarizes the adjusted resource allocation from the resource reduction operations to construct a resource reallocation scheme. This scheme details the resource type, quantity, and usage time period for each task.

[0155] By applying reordering and resource reallocation schemes to agile development tasks, the final management optimization results are obtained. The application process includes updating task execution plans, adjusting resource allocation tables, and notifying relevant team members. The management optimization results include: eliminating or mitigating the severity of resource conflicts, optimizing task execution order, rationally allocating limited resources, and ensuring the resource requirements of critical tasks are met.

[0156] In practical applications, the above optimization process requires multiple iterations. The steps are repeated for lower-priority resource conflict points until all resource conflicts are resolved or their severity is reduced to an acceptable level. This entire process forms a closed-loop resource conflict resolution mechanism, ensuring that agile development projects can execute efficiently under limited resource constraints.

[0157] By using the above methods, the resource allocation problem in agile development projects has been effectively solved, project management efficiency has been significantly improved, and a foundation has been laid for timely and high-quality project delivery.

[0158] This invention provides a requirement change tracking and management optimization system for agile development, the system comprising:

[0159] The first unit is used to perform multi-dimensional dependency analysis on agile development task objects based on agile development requirement change requests, and construct a task dependency tracking graph; it also performs pattern mining on historical requirement change tracking records, extracts recurring change impact path patterns as propagation weight correction factors, and embeds them into the task dependency tracking graph.

[0160] The second unit is used to perform bidirectional propagation path tracing of the requirement change request based on the task dependency tracing graph, and to determine the set of tasks directly and indirectly affected by the requirement change request in combination with the propagation weight correction factor.

[0161] The third unit is used to identify resource conflict points caused by the requirement change request based on the execution time window and resource occupancy status of the task set, and to perform a quantitative assessment of the conflict severity of the resource conflict points to obtain a resource conflict management list.

[0162] The fourth unit is used to construct a task priority constraint graph based on the dependency depth of the task set, and to establish resource allocation constraints according to the task priority constraint graph and the resource conflict management list.

[0163] The fifth unit is used to jointly solve the execution order and resource allocation scheme of the agile development task objects based on the dependency depth of the resource conflict management list and the task set, through the resource allocation constraints, to generate a reordering scheme and a resource reallocation scheme, and obtain management optimization results.

[0164] A third aspect of the present invention provides an electronic device, comprising:

[0165] processor;

[0166] Memory used to store processor-executable instructions;

[0167] The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0168] A fourth aspect of the present invention provides a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0169] This invention can be a method, apparatus, system, and / or computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for performing various aspects of the invention.

[0170] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features; and 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.

Claims

1. A method for optimizing requirement change tracking and management in agile development, characterized by: include: Based on the requirement change requests of agile development, multi-dimensional dependency analysis is performed on agile development task objects to construct a task dependency tracing graph. Pattern mining is performed on historical requirement change tracking records to extract recurring change impact path patterns as propagation weight correction factors and embed them into the task dependency tracking graph. Based on the task dependency tracing graph, the bidirectional propagation path of the requirement change request is traced, and the set of tasks directly and indirectly affected by the requirement change request is determined by combining the propagation weight correction factor. Based on the execution time window and resource occupancy status of the task set, identify resource conflict points caused by the requirement change request, and perform a quantitative assessment of the conflict severity of the resource conflict points to obtain a resource conflict management list. A task priority constraint graph is constructed based on the dependency depth of the task set, and resource allocation constraints are established according to the task priority constraint graph and the resource conflict management list. Based on the dependency depth between the resource conflict management list and the task set, the execution order and resource allocation scheme of the agile development task objects are jointly solved through the resource allocation constraints to generate a reordering scheme and a resource reallocation scheme, thereby obtaining management optimization results.

2. The method according to claim 1, characterized in that, Based on agile development requirement change requests, multi-dimensional dependency analysis is performed on agile development task objects to construct a task dependency tracing graph, including: Extract the code module identifiers and interface call relationships involved in the change request, identify the functional dependencies of the agile development task objects, and determine the dependency links between the agile development task objects caused by functional calls. The data input / output specifications corresponding to the agile development task objects are parsed, and data flow dependencies are established by matching the data output ports and data input ports between the agile development task objects to form a data transmission dependency path. Extract the execution preconditions and completion status constraints of the agile development task object, and construct a temporal constraint relationship; A consistency check is performed on the dependency links, the data transmission dependency paths, and the timing constraints to obtain the dependency conflict assessment results. Based on the dependency conflict assessment results, the conflicting dependencies are prioritized, and the functional dependencies, data flow dependencies, and temporal constraints are resolved according to the priority ranking results. A set of resolved dependencies is generated and fused and mapped to generate the task dependency tracking graph.

3. The method according to claim 1, characterized in that, Pattern mining is performed on historical requirement change tracking records to extract recurring change impact path patterns as propagation weight correction factors, which are then embedded into the task dependency tracking graph. Extract requirement change identifiers, affected task identifiers, and inter-task dependency propagation paths from the historical requirement change tracking records to construct a sample set of historical change impact paths. The path structure similarity of the inter-task dependency propagation paths in the historical change impact path sample set is calculated to identify path structure patterns that occur more frequently than a preset frequency threshold, thereby obtaining a set of repeated path structure patterns. The number of times each path structure pattern in the set of repeated path structure patterns appears and the number of tasks affected are counted in the set of historical change-affected paths. The influence propagation intensity value of the path structure pattern is calculated based on the number of occurrences and the number of tasks affected. The normalized value of the influence propagation intensity is used as the propagation weight correction factor. The path node sequence and dependency type sequence of the path structure pattern are used as index keys, and the propagation weight correction factor is used as index value to establish an association mapping relationship. In the task dependency tracing graph, identify dependency propagation sub-paths that match the path structure patterns in the set of repeating path structure patterns; Based on the association mapping relationship, the propagation weight correction factor corresponding to the dependency propagation sub-path is embedded into the corresponding dependency relationship edge in the task dependency tracking graph, thereby completing the integration of the propagation weight correction factor into the task dependency tracking graph.

4. The method according to claim 1, characterized in that, Based on the task dependency tracing graph, the bidirectional propagation path of the requirement change request is traced, and the set of tasks directly and indirectly affected by the requirement change request is determined by combining the propagation weight correction factor, including: Extract the change trigger task identifier from the requirement change request, and locate the initial task node corresponding to the change trigger task identifier in the task dependency tracking graph; Starting from the initial task node, a graph traversal operation is performed based on the directional identifier of the dependency relationship edge in the task dependency tracking graph, and the traversed task nodes are divided into multiple propagation levels according to the dependency level depth. Extract the propagation path between the task node within the propagation layer and the initial task node, obtain the corresponding propagation weight correction factor from the dependency edges on the propagation path, and perform path decay accumulation calculation to obtain the path propagation decay coefficient of the propagation path. The path propagation attenuation coefficients corresponding to multiple propagation paths are fused and aggregated to obtain the comprehensive impact attenuation coefficient of the task node; the comprehensive impact attenuation coefficient is combined with the propagation level depth to obtain the impact metric. Task nodes whose impact metric exceeds a preset direct impact threshold are classified as directly impacted tasks, and task nodes whose impact metric is between the preset direct impact threshold and the preset indirect impact threshold are classified as indirectly impacted tasks; the directly impacted tasks and the indirect impacted tasks are merged to obtain the task set.

5. The method according to claim 4, characterized in that, Based on the execution time window and resource occupancy status of the task set, identify resource conflict points caused by the requirement change request, and perform a quantitative assessment of the conflict severity of the resource conflict points, including: Using resource type identifiers as row indexes and time scales as column indexes, and recording the resource usage quantity of each resource type identifier at each time scale as the resource usage status, a resource time axis usage matrix is ​​constructed. Traverse the task nodes in the task set, map the execution time window of the task node to the time scale range of the resource time axis occupancy matrix, and accumulate the resource requirement of the task node to the corresponding matrix cell in the resource time axis occupancy matrix; When the resource usage of the matrix unit exceeds the preset resource capacity limit, the resource type identifier, time scale, and excess quantity corresponding to the matrix unit are marked as resource conflict points. Extract the time scale corresponding to the resource conflict point, and retrieve the task nodes whose execution time window covers the time scale in the task set to construct the conflict task node set of the resource conflict point; Extract the priority level information and resource requirement quantity of the task nodes from the set of conflicting task nodes, and calculate the priority level difference and resource requirement competition degree of the task nodes in the set of conflicting task nodes. The number of resource conflict points exceeding the limit, the priority level difference, and the resource demand competition degree are combined to obtain a quantitative score of the conflict severity of the resource conflict points.

6. The method according to claim 1, characterized in that, Based on the dependency depth of the task set, a task priority constraint graph is constructed, and resource allocation constraints are established according to the task priority constraint graph and the resource conflict management list, including: Recursively perform depth-first traversal along the dependency relationship edges in the task dependency tracking graph, and calculate the length of the longest dependency path from the initial task node to the task node for each task node as the dependency depth value of the task node. Task nodes with the same dependency depth value are grouped into the same priority level. Within the priority hierarchy, constraints are established based on the dependency relationships between task nodes; between different priority levels, constraints are established based on the magnitude of the dependency depth values; the constraints within the priority hierarchy and the constraints between the priority levels are merged to construct the task priority constraint graph. Extract resource identifiers, resource capacity limits, and resource occupancy time windows from the resource conflict management list; traverse the task nodes in the task priority constraint graph and extract the resource requirement identifiers and resource requirement time windows of the task nodes; The resource requirement identifier is matched and associated with the resource identifier. If the resource capacity limit does not meet the resource requirement of the task node, the priority order of resource allocation is determined based on the priority hierarchy relationship in the task priority constraint graph. Time conflict detection is performed by combining the resource requirement time window and the resource occupation time window to obtain the resource allocation constraint rule.

7. The method according to claim 5, characterized in that, Based on the dependency depth between the resource conflict management list and the task set, the execution order and resource allocation scheme of the agile development task objects are jointly solved through the resource allocation constraints to generate a reordering scheme and a resource reallocation scheme, resulting in management optimization results including: Based on the conflict severity metric score, resource conflict points are prioritized, and a set of conflict task nodes corresponding to the highest priority resource conflict points is extracted. Then, task nodes with smaller dependency depth values ​​are identified from the set of conflict task nodes as adjustable task nodes. The execution time window of the adjustable task node is matched with the resource capacity limit in the resource allocation constraint, an available time period that meets the resource capacity limit is searched, the execution time window of the adjustable task node is adjusted to the available time period, and a time adjustment operation is generated. For task nodes whose conflicts cannot be eliminated by time adjustment, based on the resource allocation priority in the resource allocation constraints, the resource allocation of task nodes with resource allocation weights higher than the preset weight threshold is maintained with the original resource allocation amount, and the resource allocation of task nodes with resource allocation weights lower than the preset weight threshold is reduced, generating a resource reduction operation. Summarize the adjusted execution time windows from the time adjustment operations to construct a reordering scheme; summarize the adjusted resource allocation amounts from the resource reduction operations to construct a resource reallocation scheme. The reordering scheme and the resource reallocation scheme are applied to the agile development task object to obtain the management optimization result.

8. A requirement change tracking and management optimization system for agile development, used to implement the method as described in any one of claims 1-7, characterized in that, include: The first unit is used to perform multi-dimensional dependency analysis on agile development task objects based on agile development requirement change requests and to build a task dependency tracing graph. Pattern mining is performed on historical requirement change tracking records to extract recurring change impact path patterns as propagation weight correction factors and embed them into the task dependency tracking graph. The second unit is used to perform bidirectional propagation path tracing of the requirement change request based on the task dependency tracing graph, and to determine the set of tasks directly and indirectly affected by the requirement change request in combination with the propagation weight correction factor. The third unit is used to identify resource conflict points caused by the requirement change request based on the execution time window and resource occupancy status of the task set, and to perform a quantitative assessment of the conflict severity of the resource conflict points to obtain a resource conflict management list. The fourth unit is used to construct a task priority constraint graph based on the dependency depth of the task set, and to establish resource allocation constraints according to the task priority constraint graph and the resource conflict management list. The fifth unit is used to jointly solve the execution order and resource allocation scheme of the agile development task objects based on the dependency depth of the resource conflict management list and the task set, through the resource allocation constraints, to generate a reordering scheme and a resource reallocation scheme, and obtain management optimization results.

9. An electronic device, characterized in that, include: processor; Memory used to store processor-executable instructions; The processor is configured to invoke instructions stored in the memory to execute the method according to any one of claims 1 to 7.

10. A computer-readable storage medium having computer program instructions stored thereon, characterized in that, When the computer program instructions are executed by the processor, they implement the method described in any one of claims 1 to 7.

Images