Process Model Difference Analysis for Supporting Process Evolution

Software development processes are subject to variations in time and space, variations that can originate from learning effects, differences in application domains, or a number of other causes. Identifying and analyzing such differences is crucial for a variety of process activities, like defining and evolving process standards, or analyzing the compliance of process models to existing standards, among others. In this paper, we show why appropriately identifying, describing, and visualizing differences between process models in order to support such activities is a highly challenging task. We present scenarios that motivate the need for process model difference analysis, and describe the conceptual and technical challenges arising from them. In addition, we sketch an initial tool-based approach implementing difference analysis, and contrast it with similar existing approaches. The results from this paper constitute the requirements for our ongoing development effort, whose objectives we also describe briefly.

💡 Research Summary

The paper addresses the problem of identifying, describing, and visualizing differences between software development process models, a task that becomes increasingly important as processes evolve over time and across organizational contexts. The authors begin by outlining why process variation occurs—learning effects, domain-specific adaptations, and other factors cause the same “process” to manifest in multiple, slightly divergent forms. They argue that without systematic difference analysis, activities such as defining or updating corporate process standards, tailoring processes for specific projects, assessing compliance with external standards (e.g., CMMI, ISO/IEC 12207), and transferring knowledge within an organization become error‑prone and inefficient.

Four motivating scenarios are presented: (1) standard evolution, where a baseline model must be compared with a proposed revision; (2) project‑specific tailoring, requiring a trace of what has been added, removed, or altered; (3) compliance auditing, which needs an objective mapping of the current process to a normative reference; and (4) learning analytics, where the impact of training or experience on process structure is measured. These scenarios expose the core challenges of process‑model diffing.

Conceptually, the authors note that a “process model” is a rich, hierarchical artifact composed of activities, roles, work products, rules, and inter‑element relationships. Simple name‑based matching is insufficient because two elements with the same identifier may differ in attributes, constraints, or connections. Therefore, a diff must consider structural mapping, semantic equivalence, and version lineage simultaneously. Technically, the problem is compounded by scale: large enterprises may maintain thousands of models, each containing hundreds of elements. Naïve O(n²) comparisons quickly become infeasible, necessitating indexing, pre‑filtering, and incremental computation strategies. Moreover, the results must be presented in a way that accommodates both technical experts and non‑technical stakeholders, implying the need for multiple visualizations (difference trees, annotated graphs, heat maps, etc.).

To address these issues, the paper sketches an initial tool architecture. First, process models are normalized into a common meta‑model representation (e.g., BPMN, XML, JSON). A repository stores the normalized models along with version metadata. The diff engine then performs a two‑phase analysis: (a) structural matching, which attempts a 1:1 correspondence between elements based on identifiers, hierarchy, and relationship patterns; and (b) attribute comparison, which flags changes in property values, constraints, or attached documentation. Unmatched elements are classified as additions or deletions, while matched elements with differing attributes are marked as modifications. The engine records a change log that can be queried incrementally, supporting “what‑has‑changed since version X?” scenarios.

Visualization components render the diff as an interactive tree (showing added/removed nodes) and as an overlay on the original process diagram (highlighting changed arcs). Users can filter by element type, severity of change, or compliance impact, and can drill down to see detailed attribute differences. The authors contrast their approach with existing methods: version‑control‑based textual diffs (which ignore model structure), simple graph‑matching algorithms (which lack meta‑model awareness), and proprietary tools that often require manual alignment. Their prototype distinguishes itself by being meta‑model aware, supporting incremental updates, and offering multi‑view visualizations.

Finally, the paper derives a set of functional requirements for a mature diff tool: high accuracy (minimal false positives/negatives), scalability to large model repositories, user‑friendly interfaces, and seamless integration with standards‑mapping frameworks to enable automated compliance checks. Future research directions include automatic generation of mapping rules between process meta‑models and external standards, machine‑learning techniques to predict likely process changes, and collaborative features for real‑time diff sharing among distributed teams. In sum, the authors demonstrate that systematic process‑model difference analysis is a prerequisite for effective process evolution, standard governance, and continuous improvement, and they lay out both a concrete prototype and a roadmap for further development.