Fundamental Approaches to Software Engineering

Alessandra Russo, Andy SchürrLecture Notes in Computer Science 2018 · DOI · OpenAlex

ETAPS 2018 Conference Proceedings Cover

Abstract

The FASE 2018 open access proceedings volume focuses on the development of conceptual and methodological advances in software engineering, including evaluation on realistic or pragmatic cases. It is part of the annual European Joint Conference on Theory and Practice of Software, ETAPS 2018. This summary highlights the research paper "A Formal Framework for Incremental Model Slicing" by Gabriele Taentzer, Timo Kehrer, Christopher Pietsch, and Udo Kelter, which introduces a formal, graph-based framework for extracting relevant sub-sections of complex software models.

Introduction: The Challenge of Monolithic Models

In modern software engineering, models such as statecharts or class diagrams are essential for designing complex systems. However, as these systems scale, their models often become "monolithic," containing tens of thousands of elements. Such massive models are nearly impossible for humans to navigate and can overwhelm standard editing tools.

"Slicing" is a technique adapted from source code analysis where a specific "criterion" (like a variable or state) is used to extract only the relevant parts of a system. Applying this to models, however, presents two major hurdles:

  1. Diversity: Different domain-specific modeling languages (DSMLs) require unique slicing logic.
  2. Evolution: In real-world workflows, slicing criteria change constantly. Re-generating a slice from scratch every time is computationally expensive and, more importantly, causes the loss of any manual refinements a developer might have made to that specific sub-model.

A Formal Graph-Based Framework

The authors propose a formal framework that treats models as typed graphs. This approach is built on three mathematical pillars designed to handle model evolution efficiently:

  • Graph-Based Formalism: Utilizing category theory—specifically spans of injective morphisms—the framework defines model modifications formally. This allows any change, whether a deletion or an addition, to be treated as a rigorous mathematical operation.
  • Incremental Update Construction: Rather than a "delete and replace" strategy, the framework identifies the intersection between the old and new slices. It calculates the minimal set of additions and deletions necessary to transform the existing slice into the updated one.
  • Edit Scripts: To bridge theory and practice, the framework uses "edit scripts." These are sequences of model transformation rules (implemented via the Henshin language) that describe model construction. By identifying which rules are necessary for a specific criterion, the tool can automatically assemble the required slice.

Evaluation and Implementation

The framework was evaluated using the Barbados Car Crash Crisis Management System (bCMS), a standard community benchmark for model-driven engineering. This case study demonstrated the framework's ability to perform slicing across different "viewpoints," such as linking state machine transitions to specific operations in a class diagram.

The implementation was integrated into the Eclipse Modeling Framework (EMF) ecosystem, leveraging SiLift for model differencing and Henshin for graph transformations.

Key Insights: Preserving the Developer's Workflow

The most critical insight of this research is the necessity of edit preservation. In a collaborative design environment, if a developer extracts a slice to work on it independently, a non-incremental update would overwrite their progress. Incremental slicing is therefore essential for making model-slicing viable for iterative, real-world design.

Furthermore, by defining slicing through graph morphisms, the framework remains semantically independent. Whether slicing a standard UML diagram or a custom industrial DSL, the underlying logic for updating the slice remains consistent. The authors also provided a mathematical proof ensuring that incremental updates produce results identical to non-incremental ones, guaranteeing model integrity.

Results and Future Directions

The authors successfully implemented two concrete model slicers, demonstrating that the tool can be configured for various purposes—such as backward slicing for debugging or extracting editable submodels for design—simply by adjusting transformation rules. The incremental approach effectively solves the "white-filled elements" problem, where common elements are needlessly re-processed, significantly reducing computational overhead.

While the current framework is highly effective for static slicing, future work is needed to address dynamic slicing for executable models. Additionally, the authors aim to improve handling for non-deterministic slicing paths and concurrent changes where both the base model and the slicing criterion evolve simultaneously.

Summary updated

Abstract

The FASE 2018 open access proceedings volume is focusing on the development of conceptual and methodological advances in software engineering, including evaluation on realistic or pragmatic cases. It is part of the annual European Joint Conference on theory and Practice of Software, ETAPS 2018.
BibTeX
@inproceedings{russo2018fundamental,
  author = {Alessandra Russo and Andy Schürr},
  title = {{Fundamental Approaches to Software Engineering}},
  booktitle = {Lecture Notes in Computer Science},
  year = {2018},
  doi = {10.1007/978-3-319-89363-1},
}
Figure