Software maintenance is important, but suffers from architecture information that is diverging over time (architectural drift). The Digital Architecture Twin (DArT) can support software maintenance by providing continuously recovered architecture information. But the crucial link for stakeholders to retrieve this information is missing. To fill this gap, we contribute the Architecture Information Query Language (AIQL), which enables stakeholders to access up-to-date and tailored architecture information. We derived two application scenarios in the context of continuous reverse engineering. We showed that the AIQL provides the required functionality to formulate queries for the application scenarios. In a user study, stakeholders agreed that the language is easy to understand and assessed its value to the specific stakeholder for the application scenarios.

As software systems are increasingly complex, architecture documentation becomes more important. Initial documentation of a system’s architecture needs to be kept up-to-date as the system evolves. Therefore, automated support for maintaining and evolving architecture information and documentation of interconnected and heterogeneous systems is highly beneficial to engineers, architects, and other stakeholders. To achieve this, we propose to automatically integrate recovered architecture information from heterogeneous data sources and architectural artifacts into a unified data model to create integrated views. Integrated views provide a holistic and up-to-date system representation. In this work, we present an integration approach for architecture information in a unified data model that serves as a digital architecture twin representing the current architecture of a system. We show that the integration approach successfully integrates architecture information by applying adapted metrics.

This article presents a model-based mutation framework for creating mutant systems implemented in IEC61131-3 languages. The framework is based on a meta-model of the IEC61131-3 standard. It supports 21 mutation operations, such as the addition or removal of POUs or the mutation of Structured Text and Sequential Functional Charts. Moreover, operations can be combined to create higher-order changes, such as Type III code clones. The mutation framework can be used to evaluate and improve development tools for supporting the evolution of manufacturing systems, such as regression test suite generators or clone detectors.

Products and production are inherently variable. That is, the products themselves often need to be variable-as in a car plant producing many similar, albeit not identical cars. Such flexibility allows a product to be more easily customizable. We speak of variable products. At the same time, production systems typically need to be flexible in supporting the production of different products. Such flexibility allows for a broader use of production systems, supports lower production volumes while remaining economical, or optimizes production resources to avoid delays. We speak of variable production. This chapter explores variability in products and variability during production where product variability needs to be understood together with its implications on production. Special considerations are products that are consequently used during production and the issue of hardware/software variability, which is mostly handled separately today. We provide examples from an injection molding machine and also discuss open research challenges.

Music engravers nowadays use music notation software to create scores for musical works. As is common in any creative process, many different versions of digital artifacts are created-e.g., to manage editions of the same musical work, editorial markups, or the history and genesis of compositions. In the field of software engineering, researchers have proposed the use of features, i.e., user-visible aspects of systems, to manage both revisions and variants of source code and other software artifacts. Feature-based version control systems establish and maintain feature-to-code mappings defining which parts of the artifacts realize particular features, e.g., which code implements a specific function. These mappings can then be used to generate new variants based on the artifacts by selecting the desired features. Our article provides an in-depth study on feature-based version control for music notation. Our automated approach adopts the domain-specific language (DSL) LilyPond and the feature-oriented version control system ECCO. Existing studies show that features in musical scores are often fine-grained and affect only small parts of an artifact, are scattered across noncontiguous locations in the artifact, and highly interact with each other. Such properties have strong implications for the usefulness of versioning tools. Our experiment investigates two factors related to the correctness of output from feature-based version control systems when used for symbolic music notation. We demonstrate the incremental refinement of feature-to-artifact mappings when committing DSL code. We further study the impact of the order of feature interactions on the correctness of the automatically generated music artifacts. We find that a larger feature interaction threshold produces only marginally more correct results, but fixing and recommitting incorrect variants has a more powerful effect. Our results further show that considering DSL specifics is important for versioning fine-grained and scattered features.

Software maintenance is an important part of a software system's life cycle. Maintenance tasks of existing software systems suffer from architecture information that is diverging over time (architectural drift). The Digital Architecture Twin (DArT) can support software maintenance by providing up-to-date architecture information. For this, the DArT gathers such information and co-evolves with a software system, enabling continuous reverse engineering. But the crucial link for stakeholders to retrieve this information is missing. To fill this gap, we contribute the Architecture Information Query Language (AIQL), which enables stakeholders to access up-to-date and tailored architecture information. We derived four application scenarios in the context of continuous reverse engineering. We showed that the AIQL provides the required functionality to formulate queries for the application scenarios and that the language scales for use with real-world software systems. In a user study, stakeholders agreed that the language is easy to understand and assessed its value to the specific stakeholder for the application scenarios.

Code copying and customization is a common practice to realize variability and serve the demand for custom-tailored software. The clone-and-own-approach is flexible and efficient, but does not scale with the number of variants as developers must transfer changes between clones manually, which is an error-prone and tedious task. This task becomes even more challenging, when developers reuse code not only between variants, but also within variants. As a solution, we propose a novel synchronization technique that supports developers to transfer changes applied to clones to its corresponding clone instances within a variant as well as across other variants. Our technique relies on a common model of clone relationships between and within variants, that can automatically propagate changes two-dimensional into the respective intra- and inter-clone instances. In an empirical evaluation, we demonstrate the need for this two-dimensional clone synchronization and show the usefulness and scalability of our approach using the MobileMedia case study.

With the increasing demand for customized systems and rapidly evolving technology, software engineering faces many challenges. A particular challenge is the development and maintenance of systems that are highly variable both in space (concurrent variations of the system at one point in time) and time (sequential variations of the system, due to its evolution). Recent research aims to address this challenge by managing variability in space and time simultaneously. However, this research originates from two different areas, software product line engineering and software configuration management, resulting in non-uniform terminologies and a varying understanding of concepts. These problems hamper the communication and understanding of involved concepts, as well as the development of techniques that unify variability in space and time. To tackle these problems, we performed an iterative, expert-driven analysis of existing tools from both research areas to derive a conceptual model that integrates and unifies concepts of both dimensions of variability. In this article, we first explain the construction process and present the resulting conceptual model. We validate the model and discuss its coverage and granularity with respect to established concepts of variability in space and time. Furthermore, we perform a formal concept analysis to discuss the commonalities and differences among the tools we considered. Finally, we show illustrative applications to explain how the conceptual model can be used in practice to derive conforming tools. The conceptual model unifies concepts and relations used in software product line engineering and software configuration management, provides a unified terminology and common ground for researchers and developers for comparing their works, clarifies communication, and prevents redundant developments.

Software systems become increasingly interconnected and complex, leading to a heterogeneous system landscape. This entails that architecture information and architecture documentation become more important. Currently, architecture documentation is a mostly manual task, which is costly, tedious and error prone. Even if initial documentation of a system's architecture is available, it needs to be kept up-to-date as the system evolves, as otherwise its quality will decay to a point where it does not reflect the actual system and is not useful anymore. Therefore, automated support for maintaining and evolving architecture information and documentation of complex systems is highly beneficial to architects and other stakeholders. To achieve this, architecture information must be automatically recovered from heterogeneous data sources at different points in time and consolidated and integrated to provide an up-to-date representation of the system. Subsequently, the recovered architecture information must be automatically updated whenever data sources change over time. In this work, we present an early concept of a co-evolving digital architecture twin to model the system architecture via an architecture information model that combines and relates architecture information recovered from different sources at different points in time. We propose a framework for automated recovery, integration, and co-evolution of architecture information to create and maintain a digital architecture twin that is continuously and automatically updated as the system evolves. We present the general concepts and framework and discuss use cases to motivate benefits.

These artifacts relate to the VaMoS'22 research paper "Unified Operations for Variability in Space and Time".

Code copying and customization is a common practice to realize variability and serve the demand for custom-tailored software. The clone-and-own-approach is flexible and efficient, but does not scale with the number of variants as developers must transfer changes between clones manually, which is an error-prone and tedious task. This task becomes even more challenging, when developers reuse code not only between variants, but also within variants. As a solution, we propose a novel synchronization technique that supports developers to transfer changes applied to clones to its corresponding clone instances within a variant as well as across other variants. Our technique relies on a common model of clone relationships between and within variants, that can automatically propagate changes two-dimensional into the respective intra- and inter-clone instances. In an empirical evaluation, we demonstrate the need for this two-dimensional clone synchronization and show the usefulness and scalability of our approach using the MobileMedia case study.

Semantic clones are program components with similar behavior, but different textual representation. Semantic similarity is hard to detect, and semantic clone detection is still an open issue. We present semantic clone detection via Probabilistic Software Modeling (PSM) as a robust method for detecting semantically equivalent methods. PSM inspects the structure and runtime behavior of a program and synthesizes a network of Probabilistic Models (PMs). Each PM in the network represents a method in the program and is capable of generating and evaluating runtime events. We leverage these capabilities to accurately find semantic clones. Results show that the approach can detect semantic clones in the complete absence of syntactic similarity with high precision and low error rates.

When evolving software product lines, new features are added over time and existing features are revised. Engineers also decide to merge different features or split features in other cases. Such refactoring tasks are difficult when using manually maintained feature-to-code mappings. Intensional version control systems such as ECCO overcome this issue with automatically computed feature-to-code mappings. Furthermore, they allow creating variants that have not been explicitly committed before. However, such systems are still rarely used compared to extensional version control systems like Git, which keep track of the evolution history by assigning revisions to states of a system. This paper presents an approach combining both extensional and intensional version control systems, which relies on the extensional version control system Git to store versions. Developers selectively tag existing versions to describe the evolution at the level of features. Our approach then automatically replays the evolution history to create a repository of the intensional variation control system ECCO. The approach contributes to research on refactoring features of existing product lines and migrating existing systems to product lines. We provide an initial evaluation of the approach regarding correctness and performance based on an existing system.

The development and configuration of software product lines can be challenging tasks. During development, engineers often need to focus on a particular subset of features that is relevant for them. In such cases, it would be beneficial to hide other features and their implementation. During product configuration, requirements of potentially multiple stakeholders need to be considered. Therefore, configuration often happens in stages, in which different people contribute configuration decisions for different features. Moreover, in some cases, stakeholders want to share a set of products rather than a specific one. In all these cases, the necessary operation is the same: some features from the product line are assigned a value (e.g., via a partial configuration) while other features remain configurable. In this work, we propose a subset operation that takes a product line and a partial configuration to derive a subset product line comprising only the desired subset of features and implementation artifacts. Furthermore, we present, evaluate, and publish our implementation of the proposed subset operation within the FeatureIDE framework.

Software and systems engineering is challenged by variability in space (concurrent variations at a single point in time) and time (sequential variations due to evolution). Managing both dimensions of variability independently is cumbersome and error-prone. A common foundation for operations on these dimensions is still missing, hampering the comparison and integration of existing techniques coping with variability in space and time as well as the design of new ones. In this paper, we address this problem by systematically identifying, categorizing, and unifying operations from contemporary tools and extending them to cope with both variability dimensions. Based on our gained insights, we identify gaps and trade-offs in current tools for managing variability in space and time, and discuss open challenges. The unified operations establish a common foundation that helps researchers and practitioners to gain a deeper understanding of existing techniques and tools for managing variability in space and/or time, analyze and compare them, and design new ones.

Software companies commonly develop and maintain variants of systems, with different feature combinations for different customers. Thus, they must cope with variability in space. Software companies further must cope with variability in time, when updating system variants by revising existing software features. Inevitably, variants evolve orthogonally along these two dimensions, resulting in challenges for software maintenance. Our work addresses this challenge with ECSEST (Extraction and Composition for Systems Evolving in Space and Time), an approach for locating feature revisions and composing variants with different feature revisions. We evaluated ECSEST using feature revisions and variants from six highly configurable open source systems. To assess the correctness of our approach, we compared the artifacts of input variants with the artifacts from the corresponding composed variants based on the implementation of the extracted features. The extracted traces allowed composing variants with 99-100% precision, as well as with 97-99% average recall. Regarding the composition of variants with new configurations, our approach can combine different feature revisions with 99% precision and recall on average. Additionally, our approach retrieves hints when composing new configurations, which are useful to find artifacts that may have to be added or removed for completing a product. The hints help to understand possible feature interactions or dependencies. The average time to locate feature revisions ranged from 25 to 250 seconds, whereas the average time for composing a variant was 18 seconds. Therefore, our experiments demonstrate that ECSEST is feasible and effective.

Feature annotation based on preprocessor directives is the most common mechanism in Highly-Configurable Software Systems (HCSSs) to manage variability. However, it is challenging to understand, maintain, and evolve feature fragments guarded by #ifdef directives. Yet, despite HCSSs being implemented in Version Control Systems, the support for evolving features in space and time is still limited. To extend the knowledge on this topic, we analyze the feature life cycle in space and time. Specifically, we introduce an automated mining approach and apply it to four HCSSs, analyzing commits of their entire development life cycle (13 to 20 years and 37,500 commits). This goes beyond existing studies, which investigated only differences between specific releases or entire systems. Our results show that features undergo frequent changes, often with substantial modifications of their code. The findings of our empirical analyses stress the need for better support of system evolution in space and time at the level of features. In addition to these analyses, we contribute an automated mining approach for the analysis of system evolution at the level of features. Furthermore, we also make available our dataset to foster new studies on feature evolution in HCSSs.

Software companies frequently customize and extend product lines in multiple projects concurrently to quickly deliver solutions to customers. Engineers use a distributed and feature-oriented development process, commonly supported by version control systems to track implementation-level changes. For instance, feature branches are widely used to add new or modify existing features. However, when merging back features to the product line, the information about feature-to-code mappings is usually lost. Furthermore, the granularity of merging is limited to branches, making it hard to extract and merge selected individual features from one product to another. This paper thus presents feature-oriented clone and pull operations for distributed development, which are implemented in the FORCE2 platform. Our evaluation uses variants of the ArgoUML product line to investigate the correctness and performance of our approach. The results show that the feature-oriented operations work with high precision and recall for different cases of feature interactions, also when feature implementations are scattered across many locations in the source code. The performance measurements demonstrate that the operations can be integrated in the typical workflows of engineers.