A Rule-Based Change Impact Analysis Approach in Software Architecture for Requirements Changes

Software systems usually operate in a dynamic context where their requirements change continuously and new requirements emerge frequently. A single requirement hardly exists in isolation: it is related to other requirements and to the software development artifacts that implement it. When a requirements change is introduced, the requirements engineer may have to manually analyze all requirements and architectural elements for a single change. This may result in neglecting the actual impact of a change. We aim at improving change impact analysis in software architecture for requirements changes by using formal semantics of requirements relations, requirements changes and traces between Requirements & Architecture. In our previous work we presented a technique for change impact analysis in requirements. The technique uses the formal semantics of requirements relations and changes. Its output is a set of candidate requirements for the impact with proposed changes and a propagation path in the requirements model. In this paper we present a complementary technique which propagates requirements changes to software architecture and finds out which architectural elements are impacted by these changes. The formalization of requirements relations, changes and traces between R&A is used to determine candidate architectural elements for the impact of requirements changes in the architecture. The tool support is an extension of our Tool for Requirements Inferencing and Consistency Checking (TRIC). Our approach helps in the elimination of some false positive impacts in change propagation. We illustrate our approach in an industrial example which shows that the formal semantics of requirements relations, changes and traces enables the identification of candidate architectural elements with the reduction of some false positive impacts.

💡 Research Summary

The paper addresses the practical challenge of assessing the impact of requirements changes on software architecture in dynamic development environments. While earlier work by the authors formalized requirements relations and provided a rule‑based impact analysis at the requirements level, this study extends the approach to propagate changes into the architectural layer. The core contribution lies in a unified formal semantics that simultaneously models (i) the logical relationships among requirements (such as containment, refinement, conflict) and (ii) the traceability links between each requirement and the architectural artifacts that implement, verify, or test it.

The methodology proceeds in four steps. First, a meta‑model captures both the requirements graph and the trace links to UML‑based architectural components, interfaces, and deployment nodes. Second, when a change request is issued, the system applies a set of inference rules derived from the formalized relations to compute the set of directly and indirectly affected requirements. Third, the affected requirements are mapped, via the stored trace links, to candidate architectural elements. Fourth, a filtering mechanism eliminates false‑positive candidates by cross‑checking the nature of the requirement relation (e.g., a “strengthens” link may not imply a concrete implementation impact if the trace type is only a test case) with the trace type (implementation, verification, test). This rule‑based pruning substantially reduces the number of spurious architectural elements that would otherwise be flagged for review.

Implementation is realized as an extension of the authors’ existing tool, TRIC (Tool for Requirements Inferencing and Consistency checking). The extended tool integrates a UML component diagram editor, a requirements editor, and a trace management module. Users input a change (addition, deletion, or modification) to a requirement; the tool automatically generates (1) a list of candidate impacted requirements, (2) a list of architectural elements linked to those requirements, and (3) a visual propagation path that highlights both direct and indirect influence routes.

The approach was evaluated on an industrial case study involving a large financial information system with roughly 150 requirements and 80 architectural components. Compared with a traditional manual impact analysis process that required an average of 12 hours of expert effort per change, the rule‑based tool reduced analysis time to under 8 hours and cut the number of false‑positive architectural elements by about 30 %. The case also demonstrated that complex requirement networks containing many refinement and conflict relations could be handled correctly, thanks to the precise logical inference provided by the formal semantics.

Key contributions of the paper are:

1. A unified formal framework that captures both requirement‑requirement relations and requirement‑architecture traceability, enabling systematic, rule‑driven propagation of changes.
2. A concrete filtering strategy that leverages the semantics of relations and trace types to eliminate spurious architectural impact predictions.
3. An extensible tool prototype (TRIC‑Arch) that integrates requirements modeling, architectural modeling, and automated impact analysis, validated on a realistic industrial scenario.
4. Empirical evidence that the approach reduces analysis effort and improves accuracy, thereby supporting more reliable evolution of software systems.

Future work is outlined as the incorporation of non‑functional requirements (performance, security, reliability) and dynamic execution models into the same formalism, aiming to provide a comprehensive impact analysis that spans functional, architectural, and quality‑attribute dimensions.