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.

Modern software systems are subject to continuous change and often need to exist in many variants addressing different requirements. Yet, software versions resulting from evolution in time (aka revisions) and variants resulting from evolution in space are managed radically differently, but none of the traditional technologies have been successful in effectively supporting unified revision and variant management in practice.

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.

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 observations presented here may serve for the future development of standards and tools.

The increase in productivity implied by model-driven software product line engineering is weakened by the complexity exposed to the user having to manage a multi-variant model. Recently, a new paradigm has emerged: filtered software product line engineering transfers the established check-out/modify/commit workflow from version control to variability management, allowing to iteratively develop the multi-variant model in a single-variant view. This paper demonstrates SuperMod, a tool that supports collaborative filtered model-driven product line engineering, implemented for and with the Eclipse Modeling Framework. Concerning variability management, the tool offers capabilities for editing feature models and specifying feature configurations, both being well-known formalisms in product line engineering. Furthermore, collaborative editing of product lines is provided through distributed version control. The accompanying video shows that SuperMod seamlessly integrates into existing tool landscapes, reduces the complexity of multi-variant editing, automates a large part of variability management, and ensures consistency. A tool demonstration video is available here: http://youtu.be/5XOk3x5kjFc

Model-Driven Software Engineering (MDSE), Software Product Line Engineering (SPLE) and Software Configuration Management (SCM) have been established as independent disciplines to ease different aspects of software development. The usage of models as high-level abstractions promises to increase productivity, while software product lines manage variability within a family of similar software products; software configuration management systems manage evolution and support collaborative development. In this paper, we explore the state of the art regarding the pairwise combinations MDSE/SPLE, SPLE/SCM, and MDSE/SCM and show that an integrated solution combining all three disciplines is missing. We present a conceptual framework to integrate MDSE, SPLE and SCM uniformly based on a filtered editing model. The framework implies a number of advantages, namely unconstrained variability, a reduction of cognitive complexity, improved consistency, tool independence, and a higher level of automation. Our formalism is based on a uniform versioning model for temporal, cooperative, and logical versioning of models. By an example, we show the feasibility of our approach.

Version control for models is not yet supported in an adequate way. In this paper, we address three-way merging of model versions. Based on a common base version b, two alternative versions a 1 and a 2 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 a 1 and a 2 . We present a graph algorithm to solve an important subproblem which occurs in three-way model merging: merging of (linearly) ordered collections. To create the merged version, a generalized topological sort is performed. Conflicts occur if 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 merge of versions of EMF models being instances of arbitrary Ecore models. By taking arbitrary move operations into account, the algorithm considerably goes beyond the functionality of contemporary merge tools which are based on common subsequences and thus cannot adequately handle move operations.

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.