Mining UML Repositories: Intelligent Traceability via Change Patterns

TL;DR

Software evolution is a constant battle against inconsistency. This paper presents a specialized data mining approach that treats UML model elements as "products" in a supermarket basket, using historical change patterns to suggest which parts of a design must be updated alongside others. By combining version control data with a "5W+1H" rationale framework, it replaces manual guesswork with evidence-based impact analysis.

Background: The Abstraction Gap

In modern software engineering, there is a persistent gap between high-level designs (UML) and low-level code. When a requirement changes, a developer might update the code but forget to update the corresponding Use Case or Class Diagram. Traditional traceability relies on manual links—which quickly become obsolete—or file-based mining, which is too coarse for complex modeling.

Methodology: Association Rules meet UML

The core innovation lies in applying Association Rule Mining to a versioned UML repository.

1. The Supermarket Analogy

The authors map data mining concepts to software evolution:

• Item: A specific UML model element (e.g., Class: Customer).
• Transaction: A single "Change" or Check-in operation in the SCM.
• Mining Result: "Change Traces"—rules that state: "If Element A changes, Element B changes with it in 80% of cases."

2. Architecture of Extraction

The system leverages two primary infrastructures: Odyssey-VCS (for versioning fine-grained elements) and Odyssey-CCS (for tracking the change process).

• Intra-model traces: Detecting dependencies within the same level (e.g., two Use Cases).
• Inter-model traces: Identifying cross-level links (e.g., a Use Case change that consistently triggers a Class modification).

3. The 5W+1H Rationale

Mined links are useless without context. The paper introduces an automated way to populate the 5W+1H structure (Who, When, Where, Why, What, How) by scraping metadata from the Change Control System (CCS). This answers critical developer questions like: "Why was this link created? Was it a hotfix or a planned feature?"

Experiments and Results

The approach shifts the focus from "what is the code doing" to "how do models evolve together."

• Evidence-Based Suggestions: Instead of absolute rules, the system provides "suggestions" based on Support (how frequent) and Confidence (how reliable).
• Granularity: Unlike previous work (e.g., Gall et al. or Zimmermann) that analyzed file-level changes, this approach operates at the level of UML attributes and relationships.

Figure: The detected change traces showing elements, metrics, and the associated rationale.

Critical Insight: Beyond File Histories

The academic value of this work is its recognition that Software Configuration Management (SCM) is a proxy for developer intent. By formalizing the 5W+1H rationale, the authors move traceability from a static "link" to a dynamic "narrative" of software growth.

Limitations & Future Outlook

While powerful, the approach depends heavily on the quality of SCM logs. If developers perform "giant commits" (mixing multiple changes into one), the association rules will generate false positives (noise). Future work involves summarization—using these traces to automatically identify "module experts" based on their historical impact on specific elements.

Conclusion

By treating model evolution as a mineable history, this approach provides a roadmap for maintaining consistency in complex systems. It proves that the history of how we change is just as important as the code itself.