We present a nesting-free normal form for the formalism of nested conditions and constraints in the context of finite lattices of subgraphs.

View-based development is an important technique to manage complexity and facilitate cooperation in the development of modern and complex systems of systems. This approach places high demands on view definition languages used in the development process. First, such a language needs to be approachable and extremely versatile so that developers from diverse backgrounds are able to use it and can define views for a diverse set of different tasks. Yet, the language also needs to have a precise and formal semantics so that it is possible to integrate the work performed on various views in a controlled manner to obtain a coherent overall system. In this paper, we continue previous work of equipping the NeoJoin view definition language with a formal semantics that is based on triple graph grammars (TGGs). This paves the way for obtaining automated and incremental synchronization procedures between models and views that come with high formal guarantees for their behavior. Simultaneously, our work serves as a further case study of the expressivity and usability of TGGs. We identify one gap, namely convenient support for the translation of overlapping queries from the view definition language, and tackle that gap by introducing a skip semantics for TGG rules, i.e., allowing to skip certain actions a rule prescribes, depending on the application context.

User stories (USs) are a widely used notation for expressing requirements in agile software development. A comprehensive understanding requires assessing not only individual USs, but also analysing the dependencies among them. Recent advances in AI open up new possibilities for automation. Therefore, this paper proposes an AI-based approach to analysing order dependencies. To achieve this, we first semi-formally define plain and hierarchical order dependency, which relate USs based on their actions on semantically equivalent or contained entities. Dependency analysis is realised using a modular, extensible pipeline. Our approach integrates various AI-based methods, including traditional natural language processing (NLP) techniques and large language models (LLMs), to classify actions and analyse semantic relationships. To facilitate the evaluation process, we have created a benchmark dataset comprising both expert-curated and real-world USs, containing 1,499 manually labelled dependencies. We then compare NLP techniques with encoder-based transformer- and LLM-based methods for the individual analysis steps, evaluating the overall effectiveness and efficiency of our approach. Our results suggest that AI-based dependency analysis is feasible, especially when LLM-based methods are employed. In realistic backlog settings, we obtain $\mathbf{F}_{2}$ scores of 73% for plain and 89% for hierarchical order dependency. Our approach forms the basis for automated dependency analysis in requirements engineering and enables extensions to cover additional dependency types in the future.

Conflict and dependency analysis is an important static analysis tool that provides an overview of the potential interactions of (graph) transformation rules. This analysis is based on critical pairs and initial conflicts, which represent conflicting transformations in a minimal context. However, the crucial information about a conflicting transformation pair is contained in much smaller structures, called disabling/conflict essences in existing research. Recently, we introduced disabling essences for rules with application conditions which contain the information on how an application condition can be violated by another rule. In this paper, we extend the notion of disabling essences to support not only application conditions in Alternating Quantifier Normal Form, but also arbitrary nested conditions. We introduce (symbolic) conflict essences that are constructed from disabling essences and which capture the interaction between two rules. We show that a transformation pair is parallel dependent if and only if a symbolic conflict essence can be embedded into it and relate symbolic conflict essences to initial conflicts for transformation rules with application conditions. We present our results for adhesive HLR categories, which includes several types of graph-like structures.

Once an optimisation problem has been solved, the solution may need adaptation when contextual factors change. This challenge, also known as reoptimisation, has been addressed in various problem domains, such as railway crew rescheduling, nurse rerostering, or aircraft recovery. This requires a modified problem to be solved again to ensure that the adapted solution is optimal in the new context. However, the new optimisation problem differs notably from the original problem: (i) we want to make only minimal changes to the original solution to minimise the impact; (ii) we may be unable to change some parts of the original solution (e.g., because they refer to past allocations); and (iii) we need to derive a change script from the original solution to the new solution. In this paper, we argue that Model-Driven Engineering (MDE) - in particular, the use of declarative modelling languages and model transformations for the high-level specification of optimisation problems - offers new opportunities for the systematic derivation of reoptimisation problems from the original optimisation problem specification. We focus on combinatorial reoptimisation problems and provide an initial categorisation of changing problems and strategies for deriving the corresponding reoptimisation specifications. We introduce an initial proof-of-concept implementation based on the GIPS (Graph-Based (Mixed) Integer Linear Programming Problem Specification) tool and apply it to an example resource-allocation problem: the allocation of teaching assistants to teaching sessions.

[Context and motivation] User stories (USs) are a widely used notation for requirements in agile software development. [Question/problem] In large software projects, redundancies between USs can easily occur, and unresolved redundancies can impact software quality. It is crucial for requirements engineers to know where redundancy occurs in their projects. However, some forms of redundancy may be acceptable. [Principal ideas/results] We present two automated approaches for detecting redundancy in a set of USs in order to prevent a decrease of software quality due to the realisation of redundant USs. The first approach is based on annotation graphs, containing the main actions and entities of a US. By design, this approach effectively identifies a strict form of redundancy. The second approach detects redundancies of a more semantic nature using large language models (LLMs). [Contribution] We present the concepts and tools of both approaches and evaluate their potential and limitations by applying them to a large corpus of USs. Our results show that the inherently fuzzy LLM-based approach is able to detect most of the strict redundancies and additionally finds many more non-strict semantic redundancies. Thus, this study contributes to the advancement of automated quality control of USs.

Conflict and dependency analysis is an important static analysis tool for gaining an overview of potential interactions of graph transformation rules. The analysis is based on critical pairs, which represent conflicting transformations in a minimal context. For many applications, however, the computation of complete critical pairs is unnecessarily complex. Instead, the crucial information about a conflicting pair of transformations is already contained in much smaller structures, called conflict reasons or disabling essences in existing research. So far, these structures have only been introduced for plain rules; in practical scenarios, however, transformation rules are regularly equipped with (application) conditions. In this paper, we fill this gap by lifting the computation of disabling essences to rules with conditions. It turns out that the situation is much more complex than for plain rules, where a pair of transformations is in conflict if and only if a non-trivial disabling essence embeds into the pair. However, we can show that, for every conflicting pair of transformations via rules with conditions, there is a disabling essence that embeds into this pair. For the special case of negative application conditions we can even show that a disabling essence is embeddable if and only if the transformation pair is in conflict. We work within the general context of adhesive HLR categories, which include several types of graph-like structures.

Model-driven optimization promises the availability of meta-heuristic approaches, such as evolutionary algorithms, for optimization problems to domain experts, without requiring deeper knowledge of the underlying technologies. Models directly serve as the problem specification, while model transformations form the evolutionary operators for exploring the search space. Evolutionary algorithms, however, are usually designed to operate on low-level representations (or encodings) such as bit strings or vectors of integers or real numbers. As models generally consist of multiple high-level constructs and are much more complex than the usual low-level encodings, a performance penalty is to be expected when operating directly on such models. On the other hand, models provide additional domain knowledge and, as such, allow for the design of more sophisticated evolutionary operators. In this work we compare the performance of evolutionary algorithms operating on high- and low-level representations of solutions on two problems, the class responsibility assignment problem as well as the multi-objective knapsack problem. The results show a clear advantage of high-level model representations in terms of solution quality, producing higher-quality results for all evaluated instances, which generally come at the cost of a higher total duration. The extent of the differences and their reasons are found to greatly depend on the complexity of the model and its instances.

Working with models can lead to inconsistencies, e.g., due to erroneous or contradictory actions during concurrent modeling processes. Modern modeling environments typically tolerate inconsistencies and support their detection. However, at a later stage of development, models are expected to be consistent, meaning their inconsistencies should be considered and resolved. The process of resolving model inconsistencies is commonly referred to as model repair. Our approach to model repair is semi-automatic in the sense that the repair tool computes appropriate repair plans and the modeler decides which path to take. The speciality of our approach is that the repair process can register any small improvement in the model. This allows the interaction with the user to be optimized, resulting in an approach with a high level of automation on the one hand and flexible configuration options on the other. The approach focuses on providing repair plans that do not have side effects, i.e., the computed repair plans do not inadvertently introduce a new inconsistency of already repaired constraints into the model. Since models often have a graph-like structure, we present our approach to model repair based on graphs. Our approach is completely formal—we use the algebraic graph transformation approach to prove its correctness. We also present a prototype implementation of our repair approach based on the Eclipse Modeling Framework and Henshin, a model transformation engine based on graph transformation, to perform the actual model repair. A first performance evaluation shows that graphs with up to 1000 nodes can be repaired in about 10 s.

In model-driven optimization (MDO), domain-specific models are used to define and solve optimization problems via meta-heuristic search, often via evolutionary algorithms. Models are typically evolved using mutations, which can be formally specified as graph transformations. So far, only mutations have been used to generate new solution models from existing ones; a crossover mechanism has not yet been developed. In this paper, we present a generic crossover construction for graph-like structures, which can be used to implement crossover operators for models in MDO. We prove basic properties of our construction and show how it can be used to implement a whole set of crossover operators that have been proposed for specific problems and situations on graphs. In particular, we present a specialization of our construction to models defined in the Eclipse Modeling Framework.

The optimization of business processes is an important task to increase the efficiency of the described workflows. Metaheuristic optimization, such as evolutionary search, has been used to optimize business process models, but it requires a high level of expertise that not all process designers have. Model-driven optimization (MDO) promises to make the use of metaheuristic optimization accessible to domain experts without in-depth technical expertise by allowing them to specify the optimization algorithm directly at the model level. Because this approach is less technical, the process designers can focus on the business process models and their properties. Using concrete business process optimization problems as a starting point, we discuss how MDO can be applied to these problems, what MDO would offer for business process optimization, and how the application to business processes could stimulate research on MDO.

Double-pushout rewriting is an established categorical approach to the rule-based transformation of graphs and graph-like objects. One of its standard results is the construction of concurrent rules and the Concurrency Theorem pertaining to it: The sequential application of two rules can equivalently be replaced by the application of a concurrent rule and vice versa. We extend and generalize this result by introducing generalized concurrent rules (GCRs). Their distinguishing property is that they allow identifying and preserving elements that are deleted by their first underlying rule and created by the second one. We position this new kind of composition of rules among the existing ones and obtain a Generalized Concurrency Theorem for it. Furthermore, we identify sufficient conditions for language-preserving applications of GCRs when these are computed from rules that belong to a given grammar. We conduct our work in the same generic framework in which the Concurrency Theorem has been presented, namely double-pushout rewriting in M-adhesive categories via rules equipped with application conditions.

Sequential model synchronisation is the task of propagating changes from one model to another correlated one to restore consistency. It is challenging to perform this propagation in a least-changing way that avoids unnecessary deletions (which might cause information loss). From a theoretical point of view, so-called short-cut (SC) rules have been developed that enable provably correct propagation of changes while avoiding information loss. However, to be able to react to every possible change, an infinite set of such rules might be necessary. Practically, only small sets of pre-computed basic SC rules have been used, severely restricting the kind of changes that can be propagated without loss of information. In this work, we close that gap by developing an approach to compute more complex required SC rules on-the-fly during synchronisation. These higher-order SC rules allow us to cope with more complex scenarios when multiple changes must be handled in one step. We implemented our approach in the model transformation tool eMoflon. An evaluation shows that the overhead of computing higher-order SC rules on-the-fly is tolerable and at times even improves the overall performance. Above that, completely new scenarios can be dealt with without the loss of information.

Optimization problems in software engineering typically deal with structures as they occur in the design and maintenance of software systems. In model-driven optimization (MDO), domain-specific models are used to represent these structures while evolutionary algorithms are often used to solve optimization problems. However, designing appropriate models and evolutionary algorithms to represent and evolve structures is not always straightforward. Domain experts often need deep knowledge of how to configure an evolutionary algorithm. This makes the use of model-driven meta-heuristic search difficult and expensive. We present a graph-based framework for MDO that identifies and clarifies core concepts and relies on mutation operators to specify evolutionary change. This framework is intended to help domain experts develop and study evolutionary algorithms based on domain-specific models and operators. In addition, it can help in clarifying the critical factors for conducting reproducible experiments in MDO. Based on the framework, we are able to take a first step toward identifying and studying important properties of evolutionary operators in the context of MDO. As a showcase, we investigate the impact of soundness and completeness at the level of mutation operator sets on the effectiveness and efficiency of evolutionary algorithms.

Many applications of graph transformation require rules that change a graph without introducing new consistency violations. When designing such rules, it is natural to think about the desired outcome state, i.e., the desired effect, rather than the specific steps required to achieve it; these steps may vary depending on the specific rule-application context. Existing graph-transformation approaches either require a separate rule to be written for every possible application context or lack the ability to constrain the maximal change that a rule will create. We introduce effect-oriented graph transformation, shifting the semantics of a rule from specifying actions to representing the desired effect. A single effect-oriented rule can encode a large number of induced classic rules. Which of the potential actions is executed depends on the application context; ultimately, all ways lead to Rome. If a graph element to be deleted (created) by a potential action is already absent (present), this action need not be performed because the desired outcome is already present. We formally define effect-oriented graph transformation, show how matches can be computed without explicitly enumerating all induced classic rules, and report on a prototypical implementation of effect-oriented graph transformation in Henshin.

Evolutionary algorithms usually explore a search space of solutions by means of crossover and mutation. While a mutation consists of a small, local modification of a solution, crossover mixes the genetic information of two solutions to compute a new one. For model-driven optimization (MDO), where models directly serve as possible solutions (instead of first transforming them into another representation), only recently a generic crossover operator has been developed. Using graphs as a formal foundation for models, we further refine this operator in such a way that additional well-formedness constraints are preserved: We prove that, given two models that satisfy a given set of multiplicity constraints as input, our refined crossover operator computes two new models as output that also satisfy the set of constraints.

In evolutionary algorithms, mutation and crossover are used to explore a search space for solutions. For the model-based approach to model-driven optimization, where models are used to represent solutions, no crossover operator has been introduced yet. However, theoretical and experimental evidence shows that evolutionary search can benefit from the use of crossover. We present a configurable crossover operator for models defined in the Eclipse Modeling Framework (EMF), discuss several variants of incorporating domain knowledge into this operator, and argue that it produces EMF models again. We also present a prototype implementation of our crossover operator and conduct an initial evaluation to investigate the effectiveness of evolutionary computations that use both mutation and crossover.