@article{SchwaegerlWestfechtel, author = {Schw{\"a}gerl, Felix and Westfechtel, Bernhard}, title = {Integrated revision and variation control for evolving model-driven software product lines}, series = {Software and systems modeling}, volume = {18}, journal = {Software and systems modeling}, number = {6}, publisher = {Springer Science and Business Media}, issn = {1619-1366}, doi = {10.1007/s10270-019-00722-3}, pages = {3373 -- 3420}, abstract = {Software engineering projects are faced with abstraction, which is achieved by software models, historical evolution, which is addressed by revision control, and variability, which is managed with the help of software product line engineering. Addressing these phenomena by separate tools ignores obvious overlaps and therefore fails at exploiting synergies between revision and variation control for models. In this article, we present a conceptual framework for integrated revision and variation control of model-driven software projects. The framework reuses the abstractions of revision graphs and feature models and follows an iterative, revision-control-like approach to software product line engineering called product-based product line development. A single version (i.e., a variant of a selected revision) is made available in a workspace, where the user may apply arbitrary modifications. Based on a user-provided specification of the affected variants, the changes are automatically written back to a transparent repository that relies on an internal multi-version storage. The uniform handling of revisions and variants of models is achieved by transparently mapping version concepts to a semantic base layer, which is defined upon propositional logic. At the heart of the conceptual framework is a dynamic filtered editing model, which allows that the versioned artifacts and the feature model co-evolve. We contribute algorithms for checkout and commit, which satisfy a set of consistency constraints referring to variant specifications in an evolving feature model. This article furthermore addresses the orchestration of collaborative development by distributed replication and the well formedness of text and model artifacts to be checked out into the workspace. The Eclipse-based tool SuperMod demonstrates the feasibility of the conceptual framework. It allows the user to reuse arbitrary editing tools for text-based programming and/or Ecore-based modeling languages. An evaluation based on three case studies investigates the properties of SuperMod with a specific focus on filtered editing. The evaluation demonstrates that the dynamic filtered editing model reduces the cognitive complexity and the amount of user interaction necessary for variation control when compared to unfiltered model-driven approaches to software product line engineering.}, language = {en} } @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} }