@article{LinsbauerSchwaegerlBergeretal., author = {Linsbauer, Lukas and Schw{\"a}gerl, Felix and Berger, Thorsten and Gr{\"u}nbacher, Paul}, title = {Concepts of variation control systems}, series = {Journal of Systems and Software}, volume = {171}, journal = {Journal of Systems and Software}, publisher = {Elsevier}, issn = {0164-1212}, doi = {10.1016/j.jss.2020.110796}, abstract = {Version control systems are an integral part of today's software engineering. They facilitate the collaborative management of revisions (sequential versions) and variants (concurrent versions) of software systems under development. Typical version control systems maintain revisions of files and variants of whole software systems. Variants are supported via branching or forking mechanisms that conceptually clone whole systems in a coarse-grained way. Unfortunately, such cloning leads to high maintenance efforts. To avoid these disadvantages and support fine-grained variation, developers need to employ custom configuration mechanisms, which leads to a misappropriation of tools and undesired context switches. Addressing this trade-off, a number of variation control systems has been conceived, providing a richer set of capabilities for handling variants. Variation control systems decompose a software system into finer-grained variable entities and offer high-level metaphors to automatically manage this variability. In this paper, we classify and compare variation control systems and illustrate their core concepts and characteristics. All investigated variation control systems offer an iterative (checkout-modify-commit) workflow, but there are essential differences affecting developers. We highlight challenges and discuss research perspectives for developing the next generation of version and variation control systems.}, language = {en} } @article{KynastSchwaegerlHoecker, author = {Kynast, Josef Paul and Schw{\"a}gerl, Felix and H{\"o}cker, Birte}, title = {ATLIGATOR: editing protein interactions with an atlas-based approach}, series = {Bioinformatics}, volume = {38}, journal = {Bioinformatics}, number = {23}, editor = {Martelli, Pier Luigi}, publisher = {Oxford University Press (OUP)}, issn = {1367-4803}, doi = {10.1093/bioinformatics/btac685}, pages = {5199 -- 5205}, abstract = {Abstract Motivation Recognition of specific molecules by proteins is a fundamental cellular mechanism and relevant for many applications. Being able to modify binding is a key interest and can be achieved by repurposing established interaction motifs. We were specifically interested in a methodology for the design of peptide binding modules. By leveraging interaction data from known protein structures, we plan to accelerate the design of novel protein or peptide binders. Results We developed ATLIGATOR—a computational method to support the analysis and design of a protein's interaction with a single side chain. Our program enables the building of interaction atlases based on structures from the PDB. From these atlases pocket definitions are extracted that can be searched for frequent interactions. These searches can reveal similarities in unrelated proteins as we show here for one example. Such frequent interactions can then be grafted onto a new protein scaffold as a starting point of the design process. The ATLIGATOR tool is made accessible through a python API as well as a CLI with python scripts. Availability and implementation Source code can be downloaded at github (https://www.github.com/Hoecker-Lab/atligator), installed from PyPI ('atligator') and is implemented in Python 3.}, language = {en} } @inproceedings{SchwaegerlWestfechtel, author = {Schw{\"a}gerl, Felix and Westfechtel, Bernhard}, title = {Maintaining workspace consistency in filtered editing of dynamically evolving model-driven software product lines}, series = {Proceedings of the 5th International Conference on Model-Driven Engineering and Software Development MODELSWARD - Volume 1, 15-28, 2017, Porto, Portugal}, booktitle = {Proceedings of the 5th International Conference on Model-Driven Engineering and Software Development MODELSWARD - Volume 1, 15-28, 2017, Porto, Portugal}, publisher = {SCITEPRESS - Science and Technology Publications}, doi = {10.5220/0006071800150028}, pages = {15 -- 28}, abstract = {Model-driven software product line engineering is complicated: In addition to defining a variability model, developers must deal with a multi-variant domain model. To reduce complexity, filtered editing, inspired by version control, was recently transferred to software product line engineering. On check-out, a single-variant model is derived based on a configuration of its features. On commit, the representatively applied change is scoped with the features to which it is relevant. The here considered dynamic editing model involves different kinds of evolution: The variability model and the domain model are edited concurrently. Features, which define the workspace contents or the scope of the change, may be introduced or deleted. Furthermore, the scope of a change may be revised until commit. The dynamism of this filtered editing model raises consistency problems concerning the evolving relationships between the variability model, the specified configuration, and the scope of the chan ge. This paper formalizes these constraints and presents consistency-preserving algorithms for the workspace operations check-out, commit, as well as a new operation, migrate. This way, the evolution of model-driven software product lines is managed automatically, non-disruptively, and consistently.}, language = {en} } @inproceedings{SchwaegerlWestfechtel, author = {Schw{\"a}gerl, Felix and Westfechtel, Bernhard}, title = {Perspectives on combining model-driven engineering, software product line engineering, and version control}, series = {VaMoS '17: Proceedings of the 11th International Workshop on Variability Modelling of Software-Intensive Systems, February 1 - 3, 2017, Eindhoven, Netherlands}, booktitle = {VaMoS '17: Proceedings of the 11th International Workshop on Variability Modelling of Software-Intensive Systems, February 1 - 3, 2017, Eindhoven, Netherlands}, publisher = {ACM}, address = {New York, NY, USA}, isbn = {978-1-4503-4811-9}, doi = {10.1145/3023956.3023969}, pages = {76 -- 83}, abstract = {Model-driven software engineering (MDSE), software product line engineering (SPLE), and version control (VC) have been established as three software engineering sub-disciplines dealing with raising the level of abstraction of software development, organizing variability in a systematic way, and controlling the evolution of software artifacts, respectively. Traditionally, these sub-disciplines are supported by disjoint tools, leading to undesirable context switches. In this tool-centric survey, approaches for combining MDSE, SPLE, and VC in a pair-wise or even holistic fashion are categorized and assessed. The combination of MDSE and SPLE is natural since models are used to describe both the problem and the solution space. Moreover, specific VC support for models may improve collaborative MDSE in a similar way as dedicated SPL versioning supports evolution control. Last, both VC and SPLE deal with different types of variability - in time and in space, respectively -, such that an integration promises to close the gap between historical and logical (model) versioning. Results indicate that these promises are only satisfied partly by existing approaches. To attest this, we conclude with a list of usage scenarios for combined MDSE/SPLE/VC that cannot be adequately addressed by the current tools.}, language = {en} } @incollection{SchwaegerlWestfechtel, author = {Schw{\"a}gerl, Felix and Westfechtel, Bernhard}, title = {Managing Software Product Line Evolution by Filtered Editing: The SuperMod Approach}, series = {Handbook of Re-Engineering Software Intensive Systems into Software Product Lines}, booktitle = {Handbook of Re-Engineering Software Intensive Systems into Software Product Lines}, publisher = {Springer International Publishing}, isbn = {9783031116858}, doi = {10.1007/978-3-031-11686-5_17}, pages = {429 -- 451}, abstract = {This chapter introduces SuperMod, an approach and tool to support the evolution of software product lines (SPLs) by means of a filtered editing model, which is inspired by the checkout-modify-commit workflow established in version control systems. Rather than forcing the developers into editing multi-variant artifacts of an SPL, SuperMod allows them to perform modifications successively in single-variant workspaces and to integrate the changes by indicating the logical scope, i.e., the affected variants, of the change performed. The SPL itself is managed automatically in a transparent repository by the system. As a consequence, developers may re-use the same engineering tools they also used for the development of the product variants prior to the re-engineering process. SuperMod furthermore orchestrates collaborative development and provides dedicated support for (without restricting developers to) model-driven approaches to SPL engineering. We illustrate SuperMod's capabilities by the well-known graph SPL example and discuss the practical benefits of the suggested solution to SPL evolution as well as its relation to SPL re-engineering.}, language = {en} } @incollection{BuchmannSchwaegerl, author = {Buchmann, Thomas and Schw{\"a}gerl, Felix}, title = {Advancing Negative Variability in Model-Driven Software Product Line Engineering}, series = {Communications in Computer and Information Science}, booktitle = {Communications in Computer and Information Science}, publisher = {Springer International Publishing}, address = {Cham}, isbn = {9783319563893}, issn = {1865-0929}, doi = {10.1007/978-3-319-56390-9_1}, pages = {1 -- 26}, abstract = {Model-driven software product line engineering aims at increasing the productivity of development of variational software. The principle of negative variability is realized by a multi-variant domain model, from which elements not needed for specific product variants are removed. The application of negative variability is impeded by two factors: First, metamodel restrictions lead to limited expressiveness of the multi-variant domain model. Second, unintended information loss may occur during product derivation. In this paper, we present two conceptual extensions to model-driven product line engineering based on negative variability, being alternative mappings and surrogates. Alternative mappings virtually extend the multi-variant domain model. Surrogates repair unintended information loss by context-sensitive analyses. Both extensions have been implemented in FAMILE, a model-driven product line tool that is based on EMF. Alternative mappings are defined in a dedicated mapping model. Surrogate rules may be defined in a declarative domain-specific language and are taken into account during product derivation. The added value of alternative mappings and surrogates is demonstrated by a running example, a UML-based graph library.}, language = {en} } @inproceedings{BuchmannPeinlSchwaegerl, author = {Buchmann, Thomas and Peinl, Ren{\´e} and Schw{\"a}gerl, Felix}, title = {White-box LLM-supported Low-code Engineering: A Vision and First Insights}, series = {Proceedings of the ACM/IEEE 27th International Conference on Model Driven Engineering Languages and Systems}, booktitle = {Proceedings of the ACM/IEEE 27th International Conference on Model Driven Engineering Languages and Systems}, publisher = {ACM}, address = {New York, NY, USA}, doi = {10.1145/3652620.368780}, pages = {556 -- 560}, abstract = {Low-code development (LCD) platforms promise to empower citizen developers to define core domain models and rules for business applications. However, as domain rules grow complex, LCD platforms may fail to do so effectively. Generative AI, driven by large language models (LLMs), offers source code generation from natural language but suffers from its non-deterministic black-box nature and limited explainability. Therefore, rather than having LLMs generate entire applications from single prompts, we advocate for a white-box approach allowing citizen developers to specify domain models semi-formally, attaching constraints and operations as natural language annotations. These annotations are fed incrementally into an LLM contextualized with the generated application stub. This results in deterministic and better explainable generation of static application components, while offering citizen developers an appropriate level of abstraction. We report on a case study in manufacturing execution systems, where the implementation of the approach provides first insights.}, language = {en} } @inproceedings{BuchmannSchwaegerlPeinl, author = {Buchmann, Thomas and Schw{\"a}gerl, Felix and Peinl, Ren{\´e}}, title = {To Model, to Prompt, or to Code? The Choice Is Yours: A Multi-Paradigmatic Approach to Software Development}, series = {Proceedings of the 20th International Conference on Software Technologies, 10-12.Juni 2025, Bilbao}, booktitle = {Proceedings of the 20th International Conference on Software Technologies, 10-12.Juni 2025, Bilbao}, publisher = {SCITEPRESS - Science and Technology Publications}, doi = {10.5220/0013557100003964}, pages = {296 -- 303}, abstract = {This paper considers three fundamental approaches to software development, namely manual coding, model-driven software engineering, and code generation by large language models. All of these approaches have their individual pros and cons, motivating the desire for an integrated approach. We present MoProCo, a technical solution to integrate the three approaches into a single tool chain, allowing the developer to split a software engineering task into modeling, prompting or coding sub-tasks. From a single input file consisting of static model structure, natural language prompts and/or source code fragments, Java source code is generated using a two-stage approach. A case study demonstrates that the MoProCo approach combines the desirable properties of the three development approaches by offering the appropriate level of abstraction, determinism, and dynamism for each specific software engineering sub-task.}, language = {en} } @inproceedings{BuchmannSchwaegerl, author = {Buchmann, Thomas and Schw{\"a}gerl, Felix}, title = {Ensuring well-formedness of configured domain models in model-driven product lines based on negative variability}, series = {FOSD '12: Proceedings of the 4th International Workshop on Feature-Oriented Software Development, 24. + 25. September 2012, Dresden}, booktitle = {FOSD '12: Proceedings of the 4th International Workshop on Feature-Oriented Software Development, 24. + 25. September 2012, Dresden}, publisher = {ACM Press}, address = {New York, USA}, doi = {10.1145/2377816.2377822}, pages = {37 -- 44}, abstract = {Model-driven development is a well-known practice in modern software engineering. Many tools exist which allow developers to build software in a model-based or even model-driven way, but they do not provide dedicated support for software product line development. Only recently some approaches combined model-driven engineering and software product line engineering. In this paper we present an approach that allows for combining feature models and Ecore-based domain models and provides extensive support to keep the mapping between the involved models consistent. Our key contribution is a declarative textual language which allows to phrase domain-specific consistency constraints which are preserved during the configuration process in order to ensure context-sensitive syntactical correctness of derived domain models.}, language = {en} } @inproceedings{SchwaegerlBuchmannWestfechtel, author = {Schw{\"a}gerl, Felix and Buchmann, Thomas and Westfechtel, Bernhard}, title = {Multi-variant model transformations - a problem statement}, series = {Proceedings of the 11th International Conference on Evaluation of Novel Software Approaches to Software Engineering}, booktitle = {Proceedings of the 11th International Conference on Evaluation of Novel Software Approaches to Software Engineering}, publisher = {SCITEPRESS}, isbn = {978-989-758-189-2}, issn = {2184-4895}, doi = {10.5220/0005878702030209}, pages = {203 -- 209}, abstract = {Model Transformations are a key element of Model-Driven Software Engineering. As soon as variability is involved, transformations become increasingly complicated. The lack of support for variability in model transformations impairs the acceptance of approaches to organized reuse such as software product lines. In this position paper, the general problem of multi-variant model transformations is formulated for MOF-based, XMI-serialized models. A simplistic case study is presented to specify the input and the expected output of such a transformation. Furthermore, requirements for tool support are defined, including a standardized representation of both multi-variant model instances and variability information, as well as an execution specification for multi-variant transformations. A literature review reveals that the problem is weakly identified and often solved using ad-hoc solutions; there exists no tool providing a general solution to the proposed problem statement. The observation s presented here may serve for the future development of standards and tools.}, language = {en} } @inproceedings{SchwaegerlUhrig, author = {Schw{\"a}gerl, Felix and Uhrig, Sabrina}, title = {Tool Support for the Evaluation of Matching Algorithms in the Eclipse Modeling Framework}, series = {Proceedings of the 1st International Conference on Model-Driven Engineering and Software Development, February 19-21, 2013, in Barcelona, Spain, Vol. 1}, booktitle = {Proceedings of the 1st International Conference on Model-Driven Engineering and Software Development, February 19-21, 2013, in Barcelona, Spain, Vol. 1}, publisher = {SciTePress - Science and and Technology Publications}, isbn = {978-989-8565-42-6}, issn = {2184-4348}, doi = {10.5220/0004310801010110}, pages = {101 -- 110}, abstract = {In the field of model-driven development, sophisticated support for comparing model versions is urgently needed. Unfortunately, algorithms for model matching have been rarely evaluated so far. This paper deals with two extensions to the Eclipse Modeling Framework (EMF) that facilitate the evaluation of matching algorithms for EMF models, with the goal to combine user involvement and automated testing in the evaluation process. First a tree editor is presented that allows for the manual and semi-automated creation of match models which formalize the intended matching result. Second a benchmarking procedure is implemented which - given the intended match and the actual results of matching algorithms - automatically derives the number of a and b errors in a target-performance comparison. These results are valuable for drawing conclusions about the specific qualities of matching algorithms or for finding an adequate set of parameters for a configurable algorithm.}, language = {en} } @inproceedings{BuchmannSchwaegerl, author = {Buchmann, Thomas and Schw{\"a}gerl, Felix}, title = {Using Meta-code Generation to Realize Higher-order Model Transformations}, series = {Proceedings of the 8th International Joint Conference on Software Technologies, July 29-31, 2013, in Reykjav{\´i}k, Iceland, Vol. 1}, booktitle = {Proceedings of the 8th International Joint Conference on Software Technologies, July 29-31, 2013, in Reykjav{\´i}k, Iceland, Vol. 1}, publisher = {SciTePress - Science and and Technology Publications}, isbn = {978-989-8565-68-6}, doi = {https://doi.org/10.5220/0004522305360541}, pages = {536 -- 541}, abstract = {Model-driven engineering is a wide-spread paradigm in modern software engineering. During the last couple of years, many tools and languages have been developed, which are especially designed for model transformations — a discipline which is needed in many model-driven engineering approaches. While most of the existing model-to-model tools and languages are tailored towards batch transformations for specific model instances, they lack support for generic transformation problems, where the metamodel is unknown beforehand. In this paper we present a two-step meta-code generation approach that derives a metamodel-specific modelto- model transformation from a model-to-text transformation. The approach has been successfully applied to the problem of product derivation in model-driven software product lines.}, language = {en} } @inproceedings{SchwaegerlUhrigWestfechtel, author = {Schw{\"a}gerl, Felix and Uhrig, Sabrina and Westfechtel, Bernhard}, title = {A Graph-based Algorithm for Three-way Merging of Ordered Collections in EMF Models}, series = {Science of Computer Programming}, volume = {113}, booktitle = {Science of Computer Programming}, number = {Part 1}, doi = {10.1016/j.scico.2015.02.008}, pages = {51 -- 81}, abstract = {In EMF models, ordered collections appear as the values of multi-valued structural features. Traditional, text-based version control systems do not sufficiently support three-way merging of ordered collections inside EMF models since they cannot guarantee a consistent result. The operation three-way merging is defined as follows: based on a common base version b, two alternative versions and were developed by copying and modifying the base version. To reconcile these changes, a merged version m is to be created as a common successor of and . In this paper, we present a graph algorithm to solve the problem of three-way merging of ordered collections in EMF models. Each version of a collection can be represented by means of a linearly ordered graph. To create the merged version, these graphs are combined to a merged collection graph using set formula. To create the merged collection, a generalized topological sort is performed on the merged collection graph. Conflicts occur in case the order of elements cannot be deduced automatically; these conflicts are resolved either interactively or by default rules. We have implemented the merge algorithm in our tool BTMerge, which performs a consistency-preserving three-way merge of versions of EMF models being instances of arbitrary Ecore models. Our implementation relies on an alternative form of representing multiple versions of a collection, namely a versioned collection graph which forms a superimposition of collection versions. The algorithm presented here is purely state-based. Matching and merging of collections are clearly separated sub-problems. Insertions and deletions performed on the elements of the collection are propagated into the merged version in a consistent way. Our algorithm makes only minimal assumptions with regard to the underlying product model and thus may be applied to ordered collections inside plain text or XML files. By taking arbitrary move operations into account, the algorithm considerably goes beyond the functionality of contemporary merge tools which cannot adequately handle move operations.}, language = {en} } @inproceedings{BuchmannSchwaegerl, author = {Buchmann, Thomas and Schw{\"a}gerl, Felix}, title = {Breaking the Boundaries of Meta Models and Preventing Information Loss in Model-Driven Software Product Lines}, series = {Proceedings of the 11th International Conference on Evaluation of Novel Software Approaches to Software Engineering, Vol 1, 2016, Rome, Italy}, booktitle = {Proceedings of the 11th International Conference on Evaluation of Novel Software Approaches to Software Engineering, Vol 1, 2016, Rome, Italy}, publisher = {SCITEPRESS - Science and and Technology Publications}, doi = {10.5220/0005789100730083}, pages = {83}, abstract = {Model-driven software product line engineering is an integrating discipline for which tool support has become available recently. However, existing tools are still immature and have several weaknesses. Among others, limitations in variability, caused by meta model restrictions, and unintended information loss are not addressed. In this paper, we present two conceptual extensions to model-driven product line engineering based on negative variability, being alternative mappings and surrogates. Alternative mappings allow for unconstrained variability, mitigating meta model restrictions by virtually extending the underlying multi-variant domain model. Surrogates prevent unintended information loss during product derivation based on a contextsensitive product analysis, which can be controlled by a declarative OCL-based language. Both extensions have been implemented in FAMILE, a model-driven product line tool that is based on EMF, provides dedicated consistency repair mechanisms, and completely automates application engineering. The added value of alternative mappings and surrogates is demonstrated by a running example.}, language = {en} } @inproceedings{SchwaegerlUhrigWestfechtel, author = {Schw{\"a}gerl, Felix and Uhrig, Sabrina and Westfechtel, Bernhard}, title = {Model-based tool support for consistent three-way merging of EMF models}, series = {ACME '13, Proceedings of the workshop on ACadeMics Tooling with Eclipse}, booktitle = {ACME '13, Proceedings of the workshop on ACadeMics Tooling with Eclipse}, publisher = {ACM}, address = {New York, NY, USA}, doi = {10.1145/2491279.2491281}, abstract = {Inadequate version control has been identified as a major obstacle to the application of model-driven software engineering. In particular, sophisticated support for merging model versions is urgently needed. We present a tool for merging of EMF models which may be applied to instances of arbitrary Ecore models. The tool advances the state of the art by guaranteeing a consistent merge result. Furthermore, it detects and resolves not only context-free, but also context-sensitive conflicts. Our merge tool is model-based; it relies on EMF for its implementation. Initial experiences gained from its application confirm that the merge tool operates both accurately and efficiently.}, language = {en} } @inproceedings{SchroepferSchwaegerlWestfechtel, author = {Schr{\"o}pfer, Johannes and Schw{\"a}gerl, Felix and Westfechtel, Bernhard}, title = {Consistency control for model versions in evolving model-driven software product lines}, series = {2019 ACM/IEEE 22nd International Conference on Model Driven Engineering Languages and Systems Companion (MODELS-C), Munich, Germany}, booktitle = {2019 ACM/IEEE 22nd International Conference on Model Driven Engineering Languages and Systems Companion (MODELS-C), Munich, Germany}, publisher = {IEEE}, doi = {10.1109/MODELS-C.2019.00043}, pages = {268 -- 277}, abstract = {Model-driven software product lines evolve in both time and space. Consistency control for model versions constitutes a key challenge. We propose a novel approach to consistency control called well-formedness analysis and repair: Instead of attempting to guarantee consistency of each configurable version a priori (which is hard and restrictive), consistency is controlled only when a product version is actually configured. Conflicts, i.e., violation of well-formedness constraints, are detected and repaired, driven by configurable strategies. This approach is generic; it is instantiated for feature models (for the variability model) and EMF models (as domain artifacts).}, language = {en} } @inproceedings{GreinerSchwaegerlWestfechtel, author = {Greiner, Sandra and Schw{\"a}gerl, Felix and Westfechtel, Bernhard}, title = {Realizing multi-variant model transformations on top of reused ATL specifications}, series = {Proceedings of the 5th International Conference on Model-Driven Engineering and Software Development MODELSWARD, Porto, Portugal}, volume = {1}, booktitle = {Proceedings of the 5th International Conference on Model-Driven Engineering and Software Development MODELSWARD, Porto, Portugal}, publisher = {SCITEPRESS - Science and Technology Publications}, doi = {10.5220/0006137803620373}, pages = {362 -- 373}, abstract = {Model transformations are crucial in model-driven software engineering (MDSE). While combining MDSE and software product line engineering (SPLE) techniques, summarized as model-driven product line engineering (MDPLE), promises increased productivity by relying on organized reuse, the benefits are impeded by transformation specifications designed exclusively for single-variant models. Applying single-variant model transformations to multi-variant input models results in output models lacking the variability information. Multi-variant model transformations (MVMT), which preserve variability information, have only recently been understood as an explicit research problem. In this paper, we propose an a posteriori approach towards MVMT. Following the paradigm of organized reuse, we propose to employ single-variant model transformations without modifications in a first step, and to transfer variability information afterwards based on the artifacts provided by the single-variant transformation specification. In particular, we implemented this approach for the well-known model-to-model transformation language ATL. To deduce variability information, the execution artifacts (trace and execution model) are analyzed. Then, variability annotations are transfered to the target model automatically. The implementation is evaluated based on a practically example of a Graph product line. Results exhibit that our approach outperforms the conventional solution with respect to user effort, accuracy and performance.}, language = {en} }