Software Development Lifecycle Requirements Tracking and Iteration Management Methods and Systems
By constructing dual-baseline snapshots, BFS quantitative propagation calculations, and risk grading throughout the entire software development lifecycle, the problems of decreased accuracy in change impact assessment and incomplete iteration state reproduction in existing technologies have been solved. This has enabled automated change impact assessment and iteration management, and improved the control standards and traceability of software development.
Patent Information
- Application Number
- CN202611298221.0
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-25
- Publication Date
- 2026-11-17
AI Technical Summary
In existing technologies, the impact assessment of changes in demand lifecycle management relies on manually configured static weights and thresholds, which cannot be adaptively optimized, resulting in decreased assessment accuracy, inability to automatically classify risks, incomplete comparison of historical versions, and inability to reproduce the original iteration state.
By employing methods such as iterative initiation of dual baseline snapshot solidification, BFS-based quantitative transmission calculation of change impact, risk classification and automated control decision-making, bidirectional mapping association between requirements and code, pre-release coverage deadlock verification, and final state weight self-calibration, a directed acyclic graph of requirements is constructed to automate change impact assessment and iteration management.
It achieves stability and reliability in quantifying the impact of changes, automatically classifies risks, ensures complete reproducibility and traceability of iteration states, and improves the standardization and automation of management throughout the entire software development lifecycle.
Smart Images

Figure CN123114522A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of software development and management technology, specifically to a method and system for software development lifecycle requirements tracking and iterative management. Background Technology
[0002] Software development lifecycle requirements tracking and iteration management is a sophisticated requirements control and project iteration operation and maintenance technology system that covers the entire process of software project initiation and research, requirements definition, architecture design, code development, testing and verification, online delivery, operation and maintenance optimization, and version iteration. Its core is to achieve full-link correlation, dynamic tracking and continuous optimization of user requirements, development tasks, version iteration, problem rectification and delivery results through a standardized, visualized and closed-loop management mechanism. It is a core supporting technology for high-quality delivery of software projects under modern agile development and DevOps systems.
[0003] Chinese patent CN112148252B discloses a management system and tracking method based on the entire lifecycle of software development requirements. The management system includes: a requirement management unit for registering, reviewing, and converting requirement applications; a story management unit for registering stories, associating development information, and changing status; a tracking management unit for configuring requirement and story statuses and editing status triggering logic to achieve automated tracking management; and a main control unit connected to the requirement management unit, story management unit, and tracking management unit to achieve system control.
[0004] While the aforementioned patents address the issues of incomplete requirement lifecycle management and coarse granularity of requirement status progress, they employ fixed weights and threshold parameters for change impact assessment. These parameters can only be manually configured and adjusted by management personnel, failing to incorporate real-world R&D data such as the number of lines of code modified and the scope of file changes during historical iterations to achieve adaptive iterative correction. As the product undergoes multiple iterations, the coupling relationships of requirements and the complexity of development continuously change, causing static assessment parameters to deviate from the real R&D scenario. This results in a gradual decrease in the accuracy of change impact measurement and severe distortion of the assessment results. Meanwhile, the existing solutions have not built a standardized mathematical model for the quantitative transmission of the impact of changes, lack automated spillover range extrapolation logic based on dependency links, cannot automatically classify risk levels according to the magnitude of change transmission, lack a mandatory online CCB review mechanism for high-risk changes, rely on offline manual judgment for change approval processes, and have inconsistent control standards and weak automated control capabilities. Furthermore, existing technologies do not simultaneously solidify an immutable baseline snapshot containing complete requirement items, hierarchical structure, and dependency matrix during the iteration initialization phase. Historical versions only support simple text content comparison, which cannot fully restore the causal transmission link between historical requirements. Once an online failure rollback or compliance audit verification occurs, the requirement traceability link is broken, making it difficult to fully reproduce the original state of the entire iteration process. Summary of the Invention
[0005] The purpose of this invention is to provide a method and system for tracking and iterative management of requirements throughout the software development lifecycle, in order to solve the problems mentioned in the background art. The existing technology change impact assessment uses manually configured static weights and thresholds, which cannot be adaptively optimized based on historical code change data. As the product iterates, the assessment parameters become out of touch with the actual scenario, the measurement accuracy continues to decline and the results become distorted. It cannot automatically classify risks according to the magnitude of the impact, and can only perform text comparisons on historical versions, which cannot fully reproduce the original state of the iteration.
[0006] To achieve the above objectives, the present invention provides the following technical solution: a method for software development lifecycle requirements tracking and iteration management, comprising the following steps: S1. Iteration Start-up Dual Baseline Snapshot Fixation: After the iteration start-up meeting, the system automatically triggers the iteration baseline freeze command, executes the requirement metadata model construction, static baseline snapshot archiving, and causal path snapshot fixation. S2. Quantitative Transmission Calculation of Change Impact Based on BFS: When a product manager or requirement owner initiates a requirement change request, the system automatically activates the change impact analysis engine, performs change source location and stimulus weight matching, breadth-first traversal layer-by-layer transmission, and calculation and normalization of the total impact score to obtain a quantitative impact score. S3. Risk Classification and Automated Closed-Loop Control Decision: Risk is classified based on the quantitative impact score calculated in S2 and the preset threshold, and differentiated control is implemented according to the classification results. S4. Merge Request Pre-validation: When developers finish writing code and send a merge request (MR) to the code repository, the system triggers a double pre-validation hook through the WebHook listening mechanism, including format validation and active baseline context anchoring validation. S5. Establish a two-way mapping relationship between requirements and code: After the MR passes all the checks in S4 and is successfully merged into the main branch, the system automatically triggers the mapping relationship building process, captures the metadata of this commit, and establishes a two-way hash mapping relationship between the metadata and the requirement number carried in the commit log. S6. Pre-release requirement coverage deadlock check: When the iteration ends and the system is ready to generate a new release baseline version number, the release admission coverage deadlock check is automatically executed. S7. Final State Archiving and Change Weight Self-calibration Evolution: After S6 verification is passed and the version is officially released, the system performs final state solidification and model self-calibration. S8. Baseline Structured Difference Comparison and Causal Retrospective: When a version experiences a serious online failure and requires an emergency rollback, or when the audit department requires verification of historical versions, the system provides baseline retrospective capability, which can perform structured difference rate calculation and causal retrospective restoration.
[0007] Preferably, in S1, the demand metadata model is constructed by building a directed acyclic graph of demand dependencies. ,in For the set of demand nodes, Given a set of directed dependent edges, define the basic risk coefficient for each node. Edge-dependent weights , ,in, This is the normalized value of the historical defect rate. To change the frequency normalization value, For the rating mapping value of the person in charge; Static baseline snapshot archiving: capture all iteration requirements, the three-level hierarchical structure of Epic-Feature-Story, acceptance criteria and review records, assign a unique baseline version number, and lock the baseline in read-only mode to solidify the static content of the initial iteration requirements; Causal path snapshot solidification: The dependency graph adjacency matrix is serialized into a JSON file and bound to the baseline archive. The matrix elements use 0 / 1 to represent whether there is a directed dependency edge between two points, which serves as the underlying data basis for subsequent fault backtracking and restoration of causal logic of change impact. The final output is an immutable iteration starting point state anchor point composed of a static requirement snapshot and a dependency adjacency matrix.
[0008] Preferably, in S2, the change initiating node is... Match preset stimulus weights based on change type Along the demand-directed dependency edge Perform BFS to propagate the influence downwards layer by layer; For any child node traversed by BFS The value of its affected transmission effect Calculate using the following formula: ; in, This represents the set of all directed dependent edges along the traversal path from the source node to the current node; if multiple reachable paths exist, the system selects the appropriate one. Following the worst-case scenario principle, only the maximum impact of a single change source is calculated, and multi-path scores are not superimposed. The set of affected nodes hit by all BFS traversals The total impact score is obtained by accumulating the impact values of individual nodes: ; Based on benchmark score The original total impact score is mapped to a quantitative impact score capped at 0-100: ; In the initial state where there is no historical data, Default , This refers to the complete set of required nodes within the current iteration plan; during execution, It can be dynamically updated based on historical iteration statistics.
[0009] Preferably, in S3, >80, deemed high risk: The system automatically generates a quantitative impact analysis report including the scope of impact, a list of affected nodes, and the transmission path, triggering the CCB (Change Control Committee) online review process. The change can only be implemented after the review is passed; otherwise, the change application is rejected.
[0010] 45< If the value is ≤80, it is considered a medium risk: the system will automatically approve the change and notify all responsible persons of the affected nodes of the scope of impact via in-system message or email.
[0011] ≤45, judged as low risk: the system automatically approves the change and only records the operation log for future reference.
[0012] Preferably, in S4, during the active baseline context anchoring verification, the logical expression for the verification is: ; If the Request ID has already been archived (belonging to a frozen historical baseline), the system will directly trigger the Request Map (MR) and return the following message: Modifying the code branch corresponding to the frozen historical version is prohibited. Please create a new Request based on the current active baseline and resubmit.
[0013] Preferably, in S5, the established bidirectional hash mapping relationship is written into the requirement-code association matrix. Implemented using a relational database, with a composite primary key consisting of a four-tuple: "requirement ID, submission hash value, code file path, and artifact hash value". Inverted indexes are created on both the requirement side and the code side to support bidirectional retrieval. ; The matrix supports bidirectional queries: it can retrieve all associated code commit records, code files, and artifact packages in a forward manner based on the demand ID, or it can trace back to the original demand ID in a reverse manner based on the code file path or the hash value of the commit record.
[0014] Preferably, in S6, the coverage deadlock check includes the following sub-steps: S61. Extraction of Requirement ID Set and Code ID Set: The system extracts the following two sets in parallel: (A unique set of all requirement IDs within this iteration baseline) and (A unique set of requirement IDs extracted from all code commit logs within this iteration cycle).
[0015] S62. Two-way coverage calculation: Calculate requirement coverage and code compliance rate separately. ; like or If it is an empty set, the system will directly determine that... It returns a clear error message such as "No requirement entry within the iteration baseline" or "No code commit record within the iteration cycle".
[0016] S63. Deadlock and Circuit Breaker Detection: The system performs a strict difference set null check, and the release baseline version number generator can only continue execution if the following conditions are met simultaneously: , This is the set difference operator, i.e. and It must be strictly equal to 100%.
[0017] If any difference set is not empty, the system triggers a physical circuit breaker—terminating the version number generation process and throwing a detailed list of missing items: like List the detailed requirements that have been planned but not yet implemented in code; like List the details of redundant commits that are "submitted with code but have no corresponding requirements".
[0018] Preferably, in S7, the final state curing and model self-calibration include the following sub-steps: S71, Final State Snapshot Solidification: The system solidifies the final state of all requirements, review records, and test reports within the current iteration, and archives them with the starting baseline of S1 and the code artifacts of S5 in a ternary binding to form a complete version deliverable snapshot.
[0019] S72. Quantification of actual vibration amplitude based on historical sliding window: The system counts the net number of lines of code modified for each released requirement in this iteration. With the number of documents involved , The system pulls the most recent data from the database. For each historical change of the same type, extract the set of modified line counts. With the set of files involved To eliminate the interference of extreme outliers on the baseline, the system uses the median as the historical benchmark. ; ; Based on the above historical benchmarks, the system calculates the actual vibration amplitude of this change: ; in, This is the balance coefficient, with a default value of 0.6. To prevent small positive numbers from being abnormally divided by zero, we take 0.001; when =0 or When the value is 0, the system automatically downgrades to the global default baseline value.
[0020] S73, Weight Deviation Calculation and Truncating Limitation: The preset stimulus weights used in this change in S2 will be adjusted accordingly. The deviation is compared with the optimal weights in the actual deduction. The optimal weights in the actual deduction are defined as follows: ; in, The original total impact score for this change is calculated in S2.
[0021] The formula for calculating single-time weighted deviation is: ; To prevent unreasonable and drastic changes in weights due to extreme abnormal submissions, the system introduces a truncation and limiting mechanism for single deviations: ; That is, the absolute value of a single deviation is limited to no more than 0.3. This limiting threshold ensures that the weight correction process is smooth and convergent, rather than oscillating and divergent.
[0022] S74, Sliding window average correction: System maintenance length is ( A sliding deviation window of 10 (=10) is used to store the most recent... Single deviation after truncation of the same type of change When the actual number of valid data entries in the window insufficient When the moving average degenerates into The arithmetic mean of the data; if =0 (first occurrence of this type of change), then skip this correction and keep it. The deviation remains unchanged; it is simply stored in a window for later accumulation.
[0023] Calculate the most recent The sign consistency index of the second deviation: ; in, For the sign function: when taking When >0, take 1; when When < 0, take -1; when =0 takes 0.
[0024] according to Calculate the adaptive step size for the current iteration: .
[0025] The preset weight library is corrected using an adaptive step-size sliding window averaging algorithm. ; Corrected weights Transmission impact value applied to similar changes in subsequent iterations calculate; When there is insufficient valid data in the window When, We set the value to 0 temporarily, meaning the step size is rolled back to the baseline value of 0.15.
[0026] S75. Weight Correction Record Audit: The system records the complete process of each weight correction in the audit log. This audit log allows maintenance personnel to trace the weight change trajectory and perform manual review or intervention when necessary.
[0027] Preferably, in S8, the structured difference rate is: ; when At this time, the system forces the operator to confirm twice before continuing the backtracking process; if the confirmation is successful or... At that time, the system will automatically enter the following cause-effect backtracking and restoration process.
[0028] The restoration logic is as follows: ; That is: replace the requirement dependency adjacency matrix in the current operating environment with the adjacency matrix saved in the baseline snapshot, and replace the current set of requirement nodes with the set of requirement nodes in the baseline snapshot; this operation simultaneously restores the content of static requirement entries and the dynamic dependency propagation logic; the system synchronously generates a difference patch file. Its contents are: detailed records Compared to All adjacent edges that have changed, including newly added edges, deleted edges, and edges whose target nodes have been redirected, are incremented. Each edge is represented by a source node-target node pair. List them in the form of ) and indicate the type of change, and record the complete incremental information before and after the change.
[0029] A software development lifecycle requirements tracking and iteration management system, including a master control scheduling layer and a business execution layer; The master control scheduling layer includes a master control scheduling module, which is configured to receive and distribute system-wide events, maintain and iterate the full-process state machine and solidify business orchestration rules; set a unified event entry point, complete data routing and distribution to downstream business modules based on event type and iterative running status, and have built-in module exception circuit breaker mechanism and task retry mechanism to uniformly manage global context parameters and coordinate the execution sequence and mutual calling logic of downstream business modules.
[0030] The business execution layer includes a dual-baseline snapshot solidification module, a quantitative transmission calculation module, a risk classification and control decision generation module, a pre-verification module, a bidirectional mapping association module, a deadlock verification module, a weight self-calibration optimization module, and a difference comparison and causal backtracking module. The dual-baseline snapshot solidification module builds a requirement DAG model. When the iteration starts, it captures all requirements, hierarchical structure and review records, serializes the DAG adjacency matrix and packages and stores it as a unique baseline version. It also provides a read-only loading interface for the baseline and an interface for verifying the active status of iteration requirements. The quantitative transmission calculation module maintains the code change weight mapping table, uses the BFS algorithm to traverse the demand-dependent topology links, calculates the change cascade impact value according to the established formula, and outputs the standardized impact score and the list of affected nodes after normalizing the score. The risk grading and control decision generation module configures risk grading thresholds, determines risk levels based on quantitative scores, and generates corresponding control instructions; for high-risk scenarios, it generates structured analysis reports, connects with external systems to push notifications, and initiates online review processes. The pre-verification module listens for MR commit events in the code repository, parses logs to extract requirement numbers, verifies the legality of code changes bound to requirements and the validity of the baseline to which the requirements belong, intercepts non-compliant merge requests, and outputs the verification results. The bidirectional mapping and association module collects code hashes, change files, MR R&D metadata and artifact package information, builds a bidirectional association matrix between requirements and code, and provides a unified interface for building association relationships and bidirectional traceability query to all internal modules of the system and external callers. The deadlock verification module extracts the baseline requirement set and the code-related requirement set, calculates the requirement coverage and code compliance rate, identifies missing requirements and redundant code through set difference, and controls the version release based on the verification results. The weight self-calibration optimization module statistically analyzes historical change samples and calculates benchmark indicators. It combines the actual amount of code changes to measure the change magnitude, deduce and correct model weights, constrain weight fluctuations through amplitude limiting rules, and completes adaptive weight updates and retains calibration logs by relying on sliding windows. The difference comparison and causal backtracking module compares the current data with the historical baseline topology and calculates the structured difference rate. It supports rolling back to a specified baseline version, generating incremental difference patches, and can perform secondary backtracking and rollback. It provides baseline comparison, difference analysis, and historical state restoration capabilities.
[0031] Compared with the prior art, the beneficial effects of the present invention are: 1. In this invention, after each version is officially released, the system automatically captures multi-dimensional indicators such as the total number of lines of code changes, the number of changed files, and the file hierarchy correlation to quantify the actual impact of the development. It introduces a median algorithm based on nearly 30 historical iterations to eliminate data interference caused by outliers such as emergency deployments of single requirements and temporary patch submissions. Combined with sliding deviation window constraints, deviation truncation and amplitude limiting rules, and a sign consistency adaptive step size correction mechanism, the system automatically iterates and updates the stimulus weights corresponding to different change types such as new requirements, requirement deletions, requirement range adjustments, and logic optimizations. The system retains an immutable audit log for each weight parameter correction process, the values before and after correction, and the original code data that triggered the correction. It no longer relies on manual static configuration of weights and thresholds, and can dynamically adapt to real development scenarios as product iterations and changes in the complexity of requirement coupling occur. This solves the problems of long-term deviation of static parameters and continuous decay of evaluation accuracy, and the quantitative results of change impact remain stable and reliable in the long term. 2. In this invention, all iterative requirements are decomposed into independent topological nodes, and a directed acyclic graph (DAG) of requirements is constructed, embedding a single-node risk coefficient and a dual parameter of inter-node dependency coupling weight. Starting from the changed requirement node, a breadth-first search (BFS) algorithm is used to traverse the entire dependency propagation link layer by layer. Influence factors are superimposed layer by layer using a pre-defined standardized mathematical propagation formula and normalized to output a percentage-based comprehensive score of change impact. Based on the final score, the system automatically classifies changes into high, medium, and low risk levels and configures a differentiated fully automated approval workflow strategy: high-risk changes automatically generate a complete quantitative propagation score. The analysis report forces the initiation of the online review process of the CCB Change Control Committee. Changes that fail to pass the final review are locked and cannot enter the development stage. Medium-risk changes are automatically pushed to stakeholders for record-keeping. Low-risk changes are automatically released directly. This mechanism makes up for the shortcomings of existing technologies that lack quantitative transmission models and rely solely on the subjective judgment of risks by R&D personnel based on offline experience. It unifies the standards for change judgment and control across the entire project, significantly improves the standardization and automation of the entire process of requirement change control, and effectively avoids R&D risks such as system compatibility failures, large-scale rework, and loss of version stability caused by the direct implementation of high-risk requirements without sufficient evaluation. 3. In this invention, at the initialization and startup node of each iteration task, two sets of read-only locked, tamper-proof baseline snapshots are archived and stored synchronously: the first set is a static requirement text snapshot consisting of all requirement items, acceptance rules, and priority attributes of the current iteration; the second set is a dependency adjacency matrix causal snapshot corresponding to the serialized storage of the current requirement's DAG topology structure. The two sets of snapshots together serve as the tamper-proof starting state anchor point for this iteration. In subsequent version iteration reviews, online fault emergency handling, and internal and external compliance audit scenarios, the system can automatically perform structured topology difference rate calculations on any two historical iteration baselines. When the baseline difference exceeds a preset threshold, manual secondary calculation is triggered. The system confirms and verifies the changes, while also supporting one-click complete restoration of all requirement nodes and dependency transmission matrices between nodes in historical versions. It automatically generates structured difference patch packages that can be directly applied to code repository rollback. This design breaks through the limitations of existing technologies that can only perform simple text content comparison of requirement documents and cannot restore the causal transmission links of historical requirements. In online version failure emergency rollback, R&D process traceability audit, and third-party compliance verification, it can completely reproduce the original requirement dependency logic and change transmission path of each iteration, truly achieving full-chain traceability, restoreability, and verification in R&D. It fully meets the hard management requirements of software operation and maintenance failure handling and industry compliance record keeping. Attached Figure Description
[0032] Figure 1 This is a flowchart of the software development lifecycle requirements tracking and iteration management method of the present invention; Figure 2 This is a flowchart of the pre-verification process for the merged request in the software development lifecycle requirement tracking and iteration management method of this invention; Figure 3 This is a flowchart illustrating the final state archiving and change weight self-calibration evolution of the software development lifecycle requirements tracking and iterative management method of this invention. Figure 4 This is the overall architecture diagram of the software development lifecycle requirements tracking and iteration management system of this invention. Detailed Implementation
[0033] 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.
[0034] Example 1: Refer to Figures 1-3 As shown: The software development lifecycle requirements tracking and iteration management method includes the following steps: Step 1: Iteration Start-up and Dual Baseline Snapshot Fixing: After the iteration start-up meeting, the system automatically triggers the iteration baseline freeze command, executing the following sub-steps: S11. Demand Metadata Model Construction: The system establishes a directed acyclic graph of demand dependencies. ,in For the set of demand nodes, Indicates from demand implement Defining the basic risk coefficient of a node for directed dependent edges. Edge-dependent weights ; The hierarchical decomposition tree is retrieved via API, supplemented by a visual orchestration interface for manual adjustment. This interface displays dependencies using a force-directed graph, supports dragging and dropping to adjust the start and end points of edges, as well as adding and deleting them. After each adjustment, a front-end loop detection is triggered, highlighting conflicting edges and preventing saving until correction. The adjustment result is submitted to the back-end in JSON format, overwriting the original graph.
[0035] Based on historical defect rate Frequency of change and the rating of the person in charge Weighted calculation: ,in When there is no history, take 0; ; Mapping based on the responsible person's job level (P5 to P8 and above correspond to 0.4, 0.6, 0.8, and 1.0 respectively).
[0036] The weighting coefficients (0.4, 0.3, 0.3) were calculated using the Analytic Hierarchy Process (AHP) based on historical accident attribution data. When there is no historical correlation data for the requirement, the system does not rely on the weighting formula and directly uses the weighting coefficients. =0.5, and if any historical dimension data (such as defect or change records) exists, it will be calculated according to the weighted formula, and batch configuration of coverage according to demand type is supported.
[0037] S12. Static Baseline Snapshot Archive: Capture all requirement items in the current iteration plan, the Epic-Feature-Story hierarchical decomposition tree, the acceptance criteria and review records for each item, assign a unique baseline version number (e.g., BL-v2.3.0-ITER-01), and set the baseline to read-only locked state.
[0038] S13, Causal Path Snapshot Fixing: The system will save the adjacency matrix of the current time-to-time demand dependency graph. Serialized into a lightweight JSON file, archived and stored along with the baseline version number. Adjacency matrix elements. This indicates the existence of a dependency edge. Otherwise, it is 0, where and , representing the source node number and target node number in the demand dependency graph, respectively. , This represents the total number of nodes required; this snapshot serves as the basis for restoring the causal transmission logic of changes during subsequent historical backtracking.
[0039] The stage output is an immutable iteration starting point state anchor, which includes a static requirement snapshot and a dynamic dependency matrix.
[0040] Step 2: Quantitative Transmission Calculation of Change Impact Based on BFS: When a product manager or requirement owner initiates a requirement change request, the system automatically activates the change impact analysis engine, performs change source location and stimulus weight matching, breadth-first traversal layer-by-layer transmission, and calculation and normalization of the total impact score to obtain a quantitative impact score.
[0041] (1) Changing source location and matching stimulus weights Let the change initiation node be The system matches the corresponding preset stimulus weights based on the type of change. .
[0042] The initial weight library was determined using the Delphi method (median of two rounds of anonymous expert scoring), and the complete types and weights are as follows: (2) Breadth-first traversal and layer-by-layer propagation The system changes nodes Starting from the directed dependency edge The BFS method is executed in the direction of the change, propagating the impact of the change downstream layer by layer.
[0043] For any child node traversed by BFS (At depth level d), the value of the transmission effect it is affected by. Calculate using the following formula: ; in, This represents the set of all directed dependent edges along the traversal path from the source node to the current node; if multiple reachable paths exist, the system selects the appropriate one. The maximum value operation in both scenarios is executed in the order of "path merging first, then upstream merging". The specific logic of "path merging first, then upstream merging" is as follows: when the same upstream change source... Reaching the same child node via multiple paths First, the maximum value is calculated for each path (path merging). If the child node is affected by multiple different change sources simultaneously (the system only processes a single change source at a time, a situation often seen in backtracking comparisons), then the maximum value of the impact from different sources is taken (upstream merging). This order ensures that the physical meaning of the result is always "the maximum direct impact of a single change source," rather than the superposition of multiple sources. Loop detection is performed synchronously during BFS traversal. Once a loop edge is found, the propagation is blocked and an alarm is recorded, ensuring that the calculation is always based on a directed acyclic graph.
[0044] (3) Factors affecting the calculation and normalization of total score The system sums the propagation impact values of all affected nodes to obtain the original total impact score: ; in, This represents the set of all affected nodes covered by the BFS traversal.
[0045] The system maps the raw scores to a percentage-based impact score: ; in, The baseline score is preset by the system; in the initial state where there is no historical data, Default ,in This is the set of all required nodes within the current iteration plan. If this set is empty or the calculated value is too low, a preset absolute lower limit value is used (e.g., ...). =10) to prevent the scoring from being too sensitive; during operation, It can be dynamically updated based on historical iteration statistics.
[0046] Step 3: Risk Classification and Automated Closed-Loop Management Decision-Making: Based on the quantitative impact score calculated in Step 2. Risk classification is performed based on preset thresholds, and the judgment logic is as follows: ; Implement differentiated control measures based on the classification results: High-risk scenarios >80): The system automatically generates a quantitative impact analysis report including the affected area, a list of affected nodes, and the transmission path, triggering the online review process of the CCB (Change Control Committee). The change can only be implemented after the review is approved; otherwise, the change application is rejected.
[0047] Medium-risk scenarios (45 < ≤80): The system automatically approves the change and notifies the responsible persons of all affected nodes of the scope of impact via in-system message or email.
[0048] Low-risk scenarios ≤45): The system automatically approves the change and only records the operation log for future reference.
[0049] The above-mentioned grading thresholds (high risk > 80, medium risk 45~80, low risk ≤ 45) are determined based on the following: for change events that caused P0 / P1 level failures in the 12 months prior to system launch, the empirical cumulative distribution function (ECDF) of their ImpactScore is plotted, and the 65th percentile (corresponding to 45 points) and the 85th percentile (corresponding to 80 points) are taken as the dividing points to ensure that about 15% of high-impact changes are classified into the high-risk range, which is in line with the engineering application conventions of the Pareto principle in change risk management.
[0050] Step 4: Merge Request Pre-Validation: When developers complete writing code and send a Merge Request (MR) to the code repository, the system triggers a dual pre-validation hook through the WebHook listening mechanism, including format validation and active baseline context anchoring validation.
[0051] Format validation: The system parses the commit log and forcibly extracts the unique requirement number (format example: REQ-1234). If the commit log does not contain a requirement number that conforms to the format specification, the system directly intercepts the MR and returns a commit failure message.
[0052] Active baseline context anchoring verification After extracting the requirement ID, the system calls the API interface of the baseline management module to verify whether the requirement ID belongs to the currently active iteration baseline version (i.e., the iteration range that has not been frozen and archived). The verification logic is as follows: ; If the request ID has already been archived (belonging to a frozen historical baseline), the system will directly trigger the MR and return the message: "Modifying the code branch corresponding to the frozen historical version is prohibited. Please create a new request based on the current active baseline and resubmit."
[0053] Step 5: Establish the bidirectional mapping relationship between requirements and code: After the MapReduce (MR) passes all the checks in Step 4 and is successfully merged into the main branch, the system automatically triggers the mapping relationship building process, capturing the metadata of this commit, including: commit record hash value, list of involved code files, specific line numbers of changes, MR link, and associated artifact package information (artifact name, version number, build time, and repository path, covering binary files, images, or dependency packages produced by CI / CD). Relationship Matrix Implemented using a relational database, with a composite primary key consisting of a four-tuple: "requirement ID, submission hash value, code file path, and artifact hash value". Inverted indexes are created on both the requirement side and the code side to support bidirectional retrieval. ; The matrix supports bidirectional queries: it can retrieve all associated code commit records, code files, and artifact packages in a forward manner based on the demand ID, or it can trace back to the original demand ID in a reverse manner based on the code file path or the hash value of the commit record.
[0054] Step 6, Pre-release requirement coverage deadlock check: When the iteration ends and the system is ready to generate a new release baseline version number, the release admission coverage deadlock check is automatically performed. This check is a physical-level hard gate.
[0055] Specifically, it includes the following sub-steps: S61. Extraction of Requirement ID Set and Code ID Set: The system extracts the following two sets in parallel: (A unique set of all requirement IDs within this iteration baseline) and (A unique set of requirement IDs extracted from all code commit logs within this iteration cycle).
[0056] S62. Two-way coverage calculation: Calculate requirement coverage and code compliance rate separately. The results are only used for iteration report display and manual review, and are not used in automated gate detection. ; like or Since the set is empty, the coverage calculation loses statistical significance, and the system directly determines that... It returns a clear error message such as "No requirement entry within the iteration baseline" or "No code commit record within the iteration cycle".
[0057] S63. Deadlock and Circuit Breaker Detection: The system performs a strict difference set null check, and the release baseline version number generator can only continue execution if the following conditions are met simultaneously: , This is the set difference operator, i.e. and It must be strictly equal to 100%.
[0058] If any difference set is not empty, the system triggers a physical circuit breaker—terminating the version number generation process and throwing a detailed list of missing items: like List the details of the "planned but unimplemented requirements" (i.e., the list of missing requirement IDs). like List the details of redundant commits that are "code commits but no corresponding requirements" (i.e., a list of commit records whose requirement IDs cannot be traced, including commit hashes and corresponding file paths).
[0059] Step 7, Final State Archiving and Self-calibration Evolution of Change Weights: After Step 6 verification is passed and the version is officially released, the system performs final state solidification and model self-calibration, which includes the following sub-steps: S71. Final State Snapshot Solidification: The system solidifies the final state of all requirements, review records, and test reports within the current iteration, and archives them in a ternary binding with the starting baseline of Step 1 and the code artifacts of Step 5 to form a complete version deliverable snapshot.
[0060] S72. Quantification of actual vibration amplitude based on historical sliding window: The system counts the net number of lines of code modified for each released requirement in this iteration. With the number of documents involved , Changes of the same type are categorized into the five primary change types defined in Step Two. Each type maintains its own sliding window and baseline value, without further subdivision to ensure sufficient sample size. The system pulls the most recent data from the database. For each of the 30 historical changes of the same type, extract the set of modified line counts. With the set of files involved To eliminate the interference of extreme outliers on the baseline, the median is used as the historical benchmark: ; ; Based on the above historical benchmarks, the system calculates the actual vibration amplitude of this change: ; in, This is a balancing factor used to coordinate the contribution of changes in the number of lines of code and changes in the number of files to the amplitude of the fluctuation; the default value is 0.6. To prevent small positive numbers from being abnormally divided by zero, we take 0.001; when =0 or When the value is 0 (lacking historical data of the same type), the system automatically downgrades to the global default baseline value, which can be preset by expert experience.
[0061] S73. Weight Deviation Calculation and Truncating Limitation: Calculate the preset stimulus weights used in the change in step two. The deviation is compared with the optimal weights in the actual deduction. The optimal weights in the actual deduction are defined as follows: ; in, This is the original total impact score calculated in S2 for the change. Although the formula is a dimensionless ratio, its engineering significance lies in the following: if the actual vibration is much greater than the prediction (ratio > preset weight), it indicates that the preset weight is too low and should be adjusted upwards; conversely, it should be adjusted downwards. This fitting method is only used for trend correction and does not pursue strict consistency of physical dimensions.
[0062] The formula for calculating single-time weighted deviation is: ; To prevent unreasonable and drastic changes in weights due to extreme abnormal submissions (such as submitting a large amount of third-party library code at once, or code formatting tools automatically modifying all files), the system introduces a truncation and limiting mechanism for single deviations: ; That is, the absolute value of a single deviation is limited to no more than 0.3. This limiting threshold ensures that the weight correction process is smooth and convergent, rather than oscillating and divergent.
[0063] S74, Sliding window average correction: System maintenance length is ( A sliding deviation window of 10 (=10) is used to store the most recent... Single deviation after truncation of the same type of change When the actual number of valid data entries in the window insufficient When the moving average degenerates into The arithmetic mean of the data; if =0 (first occurrence of this type of change), then skip this correction and keep it. The deviation remains unchanged; it is simply stored in a window for later accumulation.
[0064] The system calculates the latest Second-rate( =3) Indicator of sign consistency of deviation: ; in, For the sign function: when taking When >0, take 1; when When < 0, take -1; when =0 takes 0.
[0065] The system according to Calculate the adaptive step size for the current iteration: ; The step size is based on a baseline value of 0.15, and fluctuates within ±50% according to sign consistency, and is limited to the range of [0.05, 0.35] to ensure stability.
[0066] The system uses an adaptive step-size sliding window averaging algorithm to correct the preset weight library. ; Corrected weights Transmission impact value applied to similar changes in subsequent iterations calculate; When there is insufficient valid data in the window When, We set the value to 0 temporarily, meaning the step size is rolled back to the baseline value of 0.15.
[0067] S75. Weight Adjustment Record Audit: The system records the complete process of each weight adjustment in the audit log, including the requirement ID of the change, the change type, the weight values before and after the adjustment, and the single deviation. The audit log includes a summary of historical data from the sliding window involved in the calculation. This log allows operations and maintenance personnel to trace the trajectory of weight changes and perform manual review or intervention when necessary.
[0068] Step 8: Baseline Structured Difference Comparison and Causal Retrospective: When a version experiences a serious online failure and requires an emergency rollback, or when the audit department requires verification of historical versions, the system provides baseline retrospective capability, which can perform structured difference rate calculation and causal retrospective restoration.
[0069] Calculation of structured difference rate After the administrator retrieves any historical baseline version number, the system extracts the current requirement tree. Demand Tree with Historical Baseline Count the number of changes in the following three categories: The number of new required nodes compared to the baseline; The number of nodes required to be deleted compared to the baseline; The number of dependent edges that have changed (source or target node changes) compared to the baseline.
[0070] The structured difference rate is: ; when At this time, the system forces the operator to confirm twice before continuing the backtracking process; if the confirmation is successful or... At that time, the system will automatically enter the following cause-effect backtracking and restoration process.
[0071] Causal regression The restoration logic is as follows: ; In other words, the current requirement dependency adjacency matrix in the current operating environment is replaced with the adjacency matrix saved in the baseline snapshot, and the current set of requirement nodes is replaced with the set of requirement nodes in the baseline snapshot. This operation restores both the static requirement item content and the dynamic dependency propagation logic.
[0072] The system synchronously generates differential patch files. Its contents are: detailed records Compared to All adjacent edges that have changed, including newly added edges, deleted edges, and edges whose target nodes have been redirected, are incremented. Each edge is represented by a source node-target node pair. List the changes in the form of () and indicate the type of change (add / delete / redirect). This patch file also records complete incremental information before and after the change and stores it in the operation log for future reference. This patch file also supports secondary rollback of the "rollback operation" itself.
[0073] Example 2: The system adopts a microkernel architecture of "master control scheduling + business execution". The master control scheduling module serves as the sole central hub of the system, maintaining the global state machine; the dual baseline snapshot solidification module to the difference comparison and causal backtracking module are independent of each other, communicating and exchanging data asynchronously only through the master control scheduling module, forming a "highly cohesive, loosely coupled" mesh collaborative relationship.
[0074] Reference Figure 4 As shown: A software development lifecycle requirements tracking and iteration management system, including a master control scheduling layer and a business execution layer.
[0075] The master control and scheduling layer includes a master control and scheduling module. This module receives and distributes global system events, maintains and iterates the entire process state machine, and solidifies business orchestration rules. It routes data to downstream business modules based on event type and iteration status through a unified event entry point. It also sets up circuit breakers for module exceptions and retry mechanisms for tasks, and uniformly manages global context parameters (including at least the current active baseline version number). Active demand set Preset stimulus weight library And cache of intermediate results for each module), coordinate the execution sequence and calling logic of each business module, and maintain standardized data interaction contracts between each business module, encapsulating the output of upstream modules (such as key-value pairs) in a key-value pair structure. , (etc.), which are used as input parameters for downstream modules for routing.
[0076] The business execution layer includes a dual-baseline snapshot solidification module, a quantitative transmission calculation module, a risk classification and control decision generation module, a pre-verification module, a bidirectional mapping correlation module, a deadlock verification module, a weight self-calibration optimization module, and a difference comparison and causal backtracking module. The dual-baseline snapshot solidification module builds a requirement DAG model. When the iteration starts, it captures all requirements, hierarchical structure and review records, serializes the DAG adjacency matrix and packages and stores it as a unique baseline version. It provides a read-only loading interface for the baseline and an interface for verifying the active status of the iteration requirements (the solidified baseline version can only be read and write operations are prohibited). The quantitative transmission calculation module maintains the weight mapping relationship corresponding to various code changes, traverses the demand dependency topology link through the BFS traversal algorithm, completes the calculation of the cascaded impact value of the change node according to the fixed calculation formula, performs normalization processing on the original calculated score, and outputs the standardized impact score and the list of affected nodes. The risk classification and control decision generation module configures and applies risk classification thresholds, classifies risk levels based on quantitative results, generates standardized control decision instructions for different risk levels, automatically generates structured analysis reports for high-risk scenarios, and supports integration with external systems to complete message notifications and initiate online review processes. The pre-verification module listens for MR commit events in the code repository, parses the commit logs to extract the associated requirement number, verifies the legality of the code change requirements, verifies the current requirement's iteration baseline status, intercepts non-compliant merge requests, and outputs the verification results. The bidirectional mapping association module collects R&D metadata such as code submission hashes, changed files, and MR information, constructs a bidirectional association matrix between requirements and code, realizes bidirectional traceability queries from requirements to code and from code to requirements, and provides an interface for building association relationships and tracing queries. The deadlock verification module extracts the baseline requirement set and the code-related requirement set, calculates the requirement coverage and code compliance rate, identifies missing requirements and redundant code through set difference, allows the generation of release baseline version number when the verification passes, and triggers physical circuit breaker when the verification fails and outputs the requirements details of "planned but not implemented" and the redundant submission details of "code submitted but no corresponding requirement" respectively. The weight self-calibration optimization module obtains the change from the quantization propagation calculation module. Statistical analysis of historical change sample data, calculation of change benchmark indicators, calculation of the actual change magnitude based on current actual code change data, deduction and correction of model weight parameters, constraint of weight fluctuation range through amplitude limit rules, completion of weight adaptive update based on sliding window, and retention of calibration audit records; The difference comparison and causal backtracking module compares the topological differences between the current iteration data and the historical baseline snapshot, calculates the structured difference rate, supports rolling back the system data state to a specified baseline version, generates incremental difference patch files, supports secondary rollback of backtracking operations, and provides baseline comparison and version rollback interfaces.
[0077] Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing embodiments or make equivalent substitutions for some of the technical features. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.
Claims
1. A method for requirements tracking and iterative management throughout the software development lifecycle, characterized in that: Includes the following steps: S1. Iteration Start-up Dual Baseline Snapshot Fixation: After the iteration start-up meeting, the system automatically triggers the iteration baseline freeze command, executes the requirement metadata model construction, static baseline snapshot archiving, and causal path snapshot fixation. S2. Quantitative Transmission Calculation of Change Impact Based on BFS: When a product manager or requirement owner initiates a requirement change request, the system automatically activates the change impact analysis engine, performs change source location and stimulus weight matching, breadth-first traversal layer-by-layer transmission, and calculation and normalization of the total impact score to obtain a quantitative impact score. S3. Risk Classification and Automated Closed-Loop Control Decision: Risk is classified based on the quantitative impact score calculated in S2 and the preset threshold, and differentiated control is implemented according to the classification results. S4. Merge Request Pre-validation: When developers finish writing code and send a merge request to the code repository, the system triggers a double pre-validation hook through the WebHook listening mechanism, including format validation and active baseline context anchoring validation. S5. Build a bidirectional mapping relationship between requirements and code: After the MR passes all the checks in S4 and is successfully merged into the main branch, the system automatically triggers the mapping relationship building process, captures the metadata of this commit, and establishes a bidirectional hash mapping relationship between the metadata and the requirement number carried in the commit log. S6. Pre-release requirement coverage deadlock check: When the iteration ends and the system is ready to generate a new release baseline version number, the release admission coverage deadlock check is automatically executed. S7. Final State Archiving and Change Weight Self-calibration Evolution: After S6 verification is passed and the version is officially released, the system performs final state solidification and model self-calibration. S8. Baseline Structured Difference Comparison and Causal Retrospective: When a version experiences a serious online failure and requires an emergency rollback, or when the audit department requires verification of historical versions, the system provides baseline retrospective capability, which can perform structured difference rate calculation and causal retrospective restoration.
2. The software development lifecycle requirements tracking and iteration management method according to claim 1, characterized in that, In S1, the requirement metadata model is constructed by building a directed acyclic graph of requirement dependencies. ,in For the set of demand nodes, Given a set of directed dependent edges, define the basic risk coefficient for each node. Edge-dependent weights , ,in, This is the normalized value of the historical defect rate. To change the frequency normalization value, For the rating mapping value of the person in charge; Static baseline snapshot archiving: captures all iteration requirements, the three-level hierarchical structure of Epic-Feature-Story, acceptance criteria and review records, assigns a unique baseline version number and adds read-only locking; Causal path snapshot fixation: The dependency graph adjacency matrix is serialized into a JSON file and bound to the baseline archive; the matrix elements are represented by 0 / 1 to indicate whether there are directed dependency edges between nodes; The system outputs a combination of two data items: a static snapshot of all requirement items in the current iteration, and the corresponding requirement dependency adjacency matrix.
3. The software development lifecycle requirements tracking and iteration management method according to claim 1, characterized in that, In S2, the node that initiates the change is... Match preset stimulus weights based on change type Along the demand-directed dependency edge Perform BFS to propagate the influence downwards layer by layer; For any child node traversed by BFS The value of its affected transmission effect Calculate using the following formula: ; in, This represents the set of all directed dependent edges along the traversal path from the source node to the current node; if multiple reachable paths exist, take... ; The set of affected nodes hit by all BFS traversals The total impact score is obtained by summing the impact values of individual nodes: ; Based on benchmark score The original total impact score is mapped to a quantitative impact score capped at 0-100: ; In the initial state where there is no historical data, Default , This refers to the complete set of requirement nodes within the current iteration plan; during operation, It can be dynamically updated based on historical iteration statistics.
4. The software development lifecycle requirements tracking and iteration management method according to claim 1, characterized in that, In S3, the decision logic is as follows: If the risk level is >80, it is considered high-risk: the system automatically generates a quantitative impact analysis report, triggering the CCB online review; if the review is passed, the changes will be implemented; if it is not passed, the application will be rejected. 45< ≤80, judged as medium risk: The system automatically approves the change and simultaneously notifies the responsible persons of the affected nodes via in-site message or email; ≤45, judged as low risk: the system automatically approves the change and only records the operation log for future reference.
5. The software development lifecycle requirements tracking and iteration management method according to claim 1, characterized in that, In S4, the logical expression for active baseline context anchoring verification is as follows: ; If the Request ID has already been archived, the MR will be rejected and you will be prompted to resubmit based on the current active baseline.
6. The software development lifecycle requirements tracking and iteration management method according to claim 1, characterized in that, In S5, the bidirectional hash map is written into the association matrix. A composite primary key is established using a four-tuple of requirement ID, submission hash, code file path, and artifact hash, with separate inverted indexes created for the requirement side and the code side. ; Retrieve associated code submissions, files, and artifact packages based on the requirement ID, and trace back to the associated requirement ID based on the code file path or submission hash value.
7. The software development lifecycle requirements tracking and iteration management method according to claim 1, characterized in that, In S6, coverage deadlock verification includes the following sub-steps: S61. Extraction of Requirement ID Set and Code ID Set: Parallel Extraction and Two sets; S62. Two-way coverage calculation: Calculate requirement coverage and code compliance rate separately. ; like or If it is an empty set, the system will directly determine that... It returns a message indicating that there are no requirement entries within the iteration baseline or no code commit records within the iteration cycle; S63. Deadlock and Circuit Breaker Detection: If both difference sets are empty, the baseline version number generator continues execution. , This is the set difference operator, i.e. and It must be strictly equal to 100%; If any difference set is not empty, the system triggers a physical circuit breaker—terminating the version number generation process and throwing a detailed list of missing items: like List the detailed requirements that have been planned but not yet implemented in code; like List the details of redundant commits that have been submitted but do not correspond to any requirements.
8. The software development lifecycle requirements tracking and iteration management method according to claim 1, characterized in that, In S7, final state curing and model self-calibration include the following sub-steps: S71, Final State Snapshot Solidification: Solidify the final state of the current iteration requirements, review records, and test reports, and archive them after binding them with the S1 starting baseline and S5 code artifacts in a three-element configuration; S72. Quantification of actual vibration amplitude based on historical sliding window: Count the net number of lines of code modified for each released requirement in this iteration. With the number of documents involved ; Retrieve the latest data from the database For each historical change of the same type, extract the set of modified line counts. With the set of files involved Using the median as the historical benchmark, the actual vibration amplitude of this change was calculated: ; in, This is the balance coefficient, with a default value of 0.
6. To prevent small positive numbers from being abnormally divided by zero, we take 0.001; when =0 or When =0, it automatically degrades to the global default baseline value; S73, Weight Deviation Calculation and Truncating Limit: The preset stimulus weights changed in S2 will be adjusted accordingly. The optimal weights were compared with those derived from the actual simulation. The optimal weights derived from the actual simulation are: ; The formula for calculating single-time weighted deviation is: ; Introduce a cutoff and limiting mechanism for single deviations: ; S74, Sliding window average correction: maintenance length is The sliding deviation window stores the most recent Single deviation after truncation of the same type of change The actual number of valid data entries in the window insufficient When the number of valid data points is used, the arithmetic mean is calculated; if =0, only write the current deviation, do not perform correction operation; Calculate the most recent The sign consistency index of the second deviation: ; in, For the sign function: when taking When >0, take 1; when When < 0, take -1; when =0 takes the value 0; according to Calculate the adaptive step size for the current iteration: ; The preset weight library is corrected using an adaptive step-size sliding window averaging algorithm. ; When there is insufficient valid data in the window When, Temporarily set the value to 0, meaning the step size will be rolled back to the baseline value of 0.15; S75. Weight Adjustment Record Audit: Record the complete process of each weight adjustment in the audit log. The record includes the requirement ID, change type, weight before and after adjustment, single deviation, and sliding window data summary.
9. The software development lifecycle requirements tracking and iteration management method according to claim 1, characterized in that, In S8, the structured difference rate is: ; when At this time, operators are required to confirm the process a second time before continuing the backtracking; if the confirmation is successful or... When this happens, the following cause-and-effect tracing and restoration process will be automatically initiated; The restoration logic is as follows: ; The baseline snapshot rollback operation replaces the current environment's requirement dependency adjacency matrix and requirement node set, and synchronously restores the static requirement entries and dependency propagation logic; Automatically generate difference patch files Record the current matrix Relative baseline matrix The incremental changes of adjacent edges are labeled with source-target node pairs, indicating the change type and details of the increments before and after.
10. A software development lifecycle requirements tracking and iteration management system, used to implement the software development lifecycle requirements tracking and iteration management method as described in any one of claims 1 to 9, characterized in that, It includes the master control and scheduling layer and the business execution layer; The master control scheduling layer includes a master control scheduling module, which is configured to receive and distribute global system events, maintain and iterate the full-process state machine and solidify business orchestration rules; set a unified event entry point, complete data routing and distribution to downstream business modules based on event type and iterative running status, and have built-in module exception circuit breaker mechanism and task retry mechanism to uniformly manage global context parameters and coordinate the execution sequence and mutual calling logic of downstream business modules. The business execution layer includes a dual-baseline snapshot solidification module, a quantitative transmission calculation module, a risk classification and control decision generation module, a pre-verification module, a bidirectional mapping association module, a deadlock verification module, a weight self-calibration optimization module, and a difference comparison and causal backtracking module. The dual-baseline snapshot solidification module builds a requirement DAG model. When the iteration starts, it captures all requirements, hierarchical structure and review records, serializes the DAG adjacency matrix and packages and stores it as a unique baseline version, and configures the baseline read-only loading interface and the iteration requirement active status verification interface. The quantitative transmission calculation module maintains the code change weight mapping table, uses the BFS algorithm to traverse the demand dependency topology links, calculates the change cascade impact value according to the established formula, and outputs the standardized impact score and the list of affected nodes after normalizing the score. The risk grading and control decision generation module configures risk grading thresholds, determines risk levels based on quantitative scores, and generates corresponding control instructions; for high-risk scenarios, it generates structured analysis reports, connects with external systems to push notifications, and initiates online review processes. The pre-verification module listens for MR commit events in the code repository, parses the logs to extract the requirement number, verifies the legality of the code change binding requirement and the validity of the baseline to which the requirement belongs, and outputs the verification results. The bidirectional mapping and association module collects code hashes, change files, MR R&D metadata and artifact package information, builds a bidirectional association matrix between requirements and code, and configures the association relationship construction and bidirectional traceability query interface. The deadlock verification module extracts the baseline requirement set and the code-related requirement set, calculates the requirement coverage and code compliance rate, identifies missing requirements and redundant code through set difference, and controls the version release based on the verification results. The weight self-calibration optimization module statistically analyzes historical change samples and calculates benchmark indicators. It combines the actual amount of code changes to measure the change magnitude, deduce and correct model weights, constrain weight fluctuations through amplitude limiting rules, and executes weight updates and records calibration logs based on sliding windows. The difference comparison and causal backtracking module compares the current data with the historical baseline topology and calculates the structured difference rate. It supports rollback to a specified baseline version, generates incremental difference patches, and can perform secondary backtracking rollback.
Citation Information
Patent Citations
A management system and tracking method based on the full life cycle of software development requirements
CN112148252B
