Abstract Despite best efforts, various challenges remain in the creation and maintenance processes of digital twins (DTs). One of those primary challenges is the constant, continuous and omnipresent evolution of systems, their user’s needs and their environment, demanding the adaptation of the developed DT systems. DTs are developed for a specific purpose, which generally entails the monitoring, analysis, simulation or optimisation of a specific aspect of an actual system, referred to as the actual twin (AT). As such, when the twin system changes, that is either the AT itself changes, or the scope/purpose of a DT is modified, the DTs usually evolve in close synchronicity with the AT. As DTs are software systems, the best practices or methodologies for software evolution can be leveraged. This paper tackles the challenge of maintaining a (set of) DT(s) throughout the evolution of the user’s requirements and priorities and tries to understand how this evolution takes place. In doing so, we provide two contributions: (i) we develop , a visual notation form that enables reasoning on a twin system, its purposes, properties and implementation, and (ii) we introduce a set of architectural transformations that describe the evolution of DT systems. The development of these transformations is driven and illustrated by the evolution and transformations of a family home’s DT, whose purpose is expanded, changed and re-prioritised throughout its ongoing lifecycle. Additionally, we evaluate the transformations on a laboratory-scale gantry crane’s DT.

Controlling complex industrial systems can be a challenging task as it requires extensive knowledge and skills that are usually acquired through years of experience. This makes it difficult to program such expertise into machine algorithms. In this paper, we present a use case that demonstrates how we built control algorithms for a CNC machine using historical logging of observations from experts. With the advent of digital technologies, machining parts are now controlled by computer programs that offer high precision and speed. However, unforeseen scenarios can still arise, which demand operators’ attention and intervention, even with finely crafted machine programs. For our experiment, we collected data from a 5-axis Mazak Integrex i500-series CNC machine over a month manufacturing multiple instances of the same part. We collected observational states, which are sensor data that match the information operators receive and output engagement feed rates following the operator’s trajectories. Using behavioral cloning, we built an initial control policy from this data, testing three families of machine learning models: regression models, ensemble methods, and deep neural networks. The results showed that ensemble methods outperformed the baseline model significantly, proving that they have learned useful control patterns. The policies also demonstrated that ML models could eliminate noisy behaviors from operators’ actions. We believe that with interactive demonstrations in the future, these models have the potential to fully mature. Overall, our study demonstrates the feasibility of building control algorithms for complex industrial systems using historical expert demonstrations and machine learning techniques.

Wireless power transfer (WPT) to charge a wireless device (WD) using radio frequency (RF) has been a promising power supply solution in wireless networks. It should extend network lifetime and guarantee network sustainability and reliability. Charging from one energy source (ES) shared by several WDs makes the scheduling algorithm most important. This paper considers a directional ES that has significant scheduling impacts relative to the more commonly studied omnidirectional ES. The directional energy source overcomes the restrictions of broadcast energy by concentrating the power on the intended sectors and thus significantly improving energy efficiency. We propose a charging scheduling algorithm to maximize the network lifetime under several network conditions. The proposed algorithm first determines the charging duration for all WDs in a given sector. The algorithm then determines the transmit power from ES to each WD in the sector. The performance of the proposed algorithm is compared with that of a well-established benchmark scheme. The extensive simulation results demonstrate the effectiveness of our proposed algorithm.

The companies that have adopted the Model-Driven Engineering (MDE) paradigm have the advantage of working at a high level of abstraction. Nevertheless, they have the disadvantage of the lack of tools available to perform bug localization at the model level. In addition, in an MDE context, a bug can be related to different MDE artefacts, such as design-time models, model transformations, or run-time models. Starting the bug localization in the wrong place or with the wrong tool can lead to a result that is unsatisfactory. We evaluate how to apply the existing model-based approaches in order to mitigate the effect of starting the localization in the wrong place. We also take into account that software engineers can refine the results at different stages. In our evaluation, we compare different combinations of the application of bug localization approaches and human refinement. The combination of our approaches plus manual refinement obtains the best results. We performed a statistical analysis to provide evidence of the significance of the results. The conclusions obtained from this evaluation are: humans have to be involved at the right time in the process (or results can even get worse), and artefact-independence can be achieved without worsening the results.

The new Industry 4.0 envisions a future for agile and effective integration of the physical operational technologies (OT) and the cyber information technologies (IT) as well as autonomous cooperation among them. However, the wide variety and heterogeneity of industrial systems and field devices -especially on the factory floor - increase integration complexity. To address these challenges, new technologies and concepts such as the Industrial Internet of Things (IIoT), Service-oriented Architecture (SoA), Semantic Technologies, Machine Learning and Artificial Intelligence are being introduced to the industrial environment. In this paper, we focus on how industrial automation systems and field devices can be integrated into the IIoT framework and coordinated to adapt to dynamic operating environment. Specifically, this paper proposed an interoperability solution that makes use of SoA and Semantic Technologies to achieve supervised coordination of IIoT application systems. To illustrate the potential of this approach, the Service-oriented Architecture-based Arrowhead Framework is used as the fundamental framework for the implementation of the approach.

Internet of Things (IoT) refers to a system of interconnected heterogeneous smart devices communicating without human intervention. A significant portion of existing IoT networks is under the umbrella of ad-hoc and quasi ad-hoc networks. Ad-hoc based IoT networks suffer from the lack of resource-rich network infrastructures that are able to perform heavyweight network management tasks using, e.g. machine learning-based Network Traffic Monitoring and Analysis (NTMA) techniques. Designing light-weight NTMA techniques that do not need to be (re-) trained has received much attention due to the time complexity of the training phase. In this study, a novel pattern recognition method, called Trend-based Online Network Traffic Analysis (TONTA), is proposed for ad-hoc IoT networks to monitor network performance. The proposed method uses a statistical light-weight Trend Change Detection (TCD) method in an online manner. TONTA discovers predominant trends and recognizes abrupt or gradual time-series dataset changes to analyze the IoT network traffic. TONTA is then compared with RuLSIF as an offline benchmark TCD technique. The results show that TONTA detects approximately 60% less false positive alarms than RuLSIF.

Problem: Modern systems contain parts that are themselves systems. Such complex systems thus have sets of subsystems that have their own variability. These subsystems contribute to the functionality of a whole system-of-systems (SoS). Such systems have a very high degree of variability. Therefore, a modeling technique for the variability of an entire SoS is required to express two different levels of variability: variability of the SoS as a whole and variability of subsystems. If these levels are described together, the model becomes hard to understand. When the variability model of the SoS is described separately, each variability model is represented by a tree structure and these models are combined in a further tree structure. For each node in a variability model, a quantity is assigned to express the multiplicity of its instances per one instance of its parent node. Quantities of the whole system may refer to the number of subsystem instances in the system. From the viewpoint of the entire system, constraints and requirements written in natural language are often ambiguous regarding the quantities of subsystems. Such ambiguous constraints and requirements may lead to misunderstandings or conflicts in an SoS configuration. Approach: A separate notion is proposed for variability of an SoS; one model considers the SoS as an undivided entity, while the other considers it as a combination of subsystems. Moreover, a domain-specific notation is proposed to express relationships among the variability properties of systems, to solve the ambiguity of quantities and establish the total validity. This notation adapts an approach, named Pincer Movement, which can then be used to automatically deduce the quantities for the constraints and requirements. Validation: The descriptive capability of the proposed notation was validated with four examples of cloud providers. In addition, the proposed method and description tool were validated through a simple experiment on describing variability models with real practitioners.

Many Internet of Things (IoT) networks are created as an overlay over traditional ad-hoc networks such as Zigbee. Moreover, IoT networks can resemble ad-hoc networks over networks that support device-to-device (D2D) communication, e.g., D2D-enabled cellular networks and WiFi-Direct. In thesead-hoctypes of IoT networks, efficienttopology managementis a crucial requirement, and in particular in massive scale deployments. Traditionally,clusteringhas been recognized as a common approach for topology management in ad-hoc networks, e.g., in Wireless Sensor Networks (WSNs). Topology management in WSNs and ad-hoc IoT networks has many design commonalities as both need to transfer data to the destination hop by hop. Thus, WSN clustering techniques can presumably be applied for topology management in ad-hoc IoT networks. This requires a comprehensive study on WSN clustering techniques and investigating their applicability to ad-hoc IoT networks. In this article, we conduct a survey of this field based on theobjectivesfor clustering, such as reducing energy consumption and load balancing, as well as the network properties relevant for efficient clustering in IoT, such as network heterogeneity and mobility. Beyond that, we investigate the advantages and challenges of clustering when IoT is integrated with modern computing and communication technologies such as Blockchain, Fog/Edge computing, and 5G. This survey provides useful insights into research on IoT clustering, allows broader understanding of its design challenges for IoT networks, and sheds light on its future applications in modern technologies integrated with IoT.

Wireless powered communication networks (WPCN) which allow an energy source (ES) to wirelessly transfer its power to a wireless device (WD) is becoming a promising technology in modern wireless networks. Besides extending network longevity, WPCN eliminates the need for frequent manual battery replacement or recharging. Even WPCN is a potential solution, how to optimize network lifetime to guarantee network substantiality and reliability is challenging. This problem has not yet been considered carefully in literature. In addition, existing related works do not consider both uplink and downlink traffic which directly impact device lifetime as well as network lifetime. This paper, therefore, deals with the problem of optimizing network lifetime by appropriately scheduling transmitted power from an ES to each WD. To this end, the paper first proposes models for device lifetime and network lifetime. Based on the models, the strategy to optimize network lifetime is derived. The paper then proposes a power scheduling algorithm performed at an ES to maximize network lifetime under several network conditions. The proposed algorithm takes into account bi-directional traffic at each WD. The proposed models and the performance of power scheduling algorithm are verified by simulations. The paper is an useful guideline to assess reliability duration of the network and provides several directions to ensure network reliability and substantiality.

Wireless Sensor Networks (WSNs) typically include thousands of resource-constrained sensors to monitor their surroundings, collect data, and transfer it to remote servers for further processing. Although WSNs are considered highly flexible ad-hoc networks, network management has been a fundamental challenge in these types of networks given the deployment size and the associated quality concerns such as resource management, scalability, and reliability. Topology management is considered a viable technique to address these concerns. Clustering is the most well-known topology management method in WSNs, grouping nodes to manage them and/or executing various tasks in a distributed manner, such as resource management. Although clustering techniques are mainly known to improve energy consumption, there are various quality-driven objectives that can be realized through clustering. In this paper, we review comprehensively existing WSN clustering techniques, their objectives and the network properties supported by those techniques. After refining more than 500 clustering techniques, we extract about 215 of them as the most important ones, which we further review, catergorize and classify based on clustering objectives and also the network properties such as mobility and heterogeneity. In addition, statistics are provided based on the chosen metrics, providing highly useful insights into the design of clustering techniques in WSNs.

Industrial cyber-physical systems are advancing rapidly along with the emergence of the fourth industrial revolution. It is, therefore, necessary to design and develop appropriate tools and frameworks that allow the migration/integration of legacy systems into the new Industry 4.0 environment. OPC-UA is one of the recommended technologies to enable communication and interoperability of digitalized assets in Industry 4.0. This paper proposes a solution to develop an OPC-UA interface for industrial systems for service-oriented architecture. With the use of the Arrowhead Framework - a cloud-based framework facilitating interoperability and integrability of Industrial Internet of Things - and Industry 4.0-compliant technologies, the authors describe the procedure of developing different application systems which dynamically produce and consume OPC-UA services within a local automation cloud.

Introducing semantics into the Internet of Things (IoT) has been attracting increasing attention from researchers and industrial practitioners. Semantic technologies have been used to enable interoperability as well as deal with the heterogeneity, massive scale, and dynamic nature of IoT resources. With the emergence of Industry 4.0, semantic technologies arise as a potential approach toward information modeling and dynamic reconfiguration of highly complex automation systems with high diversity of domains, protocols, tools or hardware platforms. Applying semantics into existing IoT frameworks requires a thorough understanding of the framework architectures as well as careful considerations of different semantic technologies. To support this process, we survey the literature on the contributions and usage of semantics in IoT. We find that semantics are mainly used to handle interoperable systems and heterogeneous standards. In this paper, we also propose procedures for applying semantics into IoT frameworks. Further, we present our idea of using semantics to enable dynamical orchestration of services within the Arrowhead Framework - an IoT framework that supports the development of industrial automation systems.

The application of search-based software engineering techniques to new problems is increasing. Feature location is one of the most important and common activities performed by developers during software maintenance and evolution. Features must be located across families of products and the software artifacts that realize each feature must be identified. However, when dealing with industrial software artifacts, the search space can be huge. We propose and compare five search algorithms to locate features over families of product models guided by latent semantic analysis (LSA), a technique that measures similarities between textual queries. The algorithms are applied to two case studies from our industrial partners (leading manufacturers of home appliances and rolling stock) and are compared in terms of precision and recall. Statistical analysis of the results is performed to provide evidence of the significance of the results. The combination of an evolutionary algorithm with LSA can be used to locate features in families of models from industrial scenarios such as the ones from our industrial partners.

Trend change detection methods find trends in a dataset. Datasets based on Poisson distribution are important to analyze since they mimic many different applications such as computer networks. Our use-cases are simulations of computer networks. The last significant trend is the last predominant trend in a time-series dataset. Our method is a matrix based trend change detection that can analyze datasets with variable sizes. Reducing the time complexity and increasing the accuracy when determining the last significant trend are the goals of our method. We compare our method with RuLSIF, a basic change point detection method, to illustrate the benefits of our approach.

Advances in the Internet of Things (IoT) domain thrusts home automation into the spotlight. Home automation is a heterogeneous realm with various and often not compatible technologies. As any not standardized area, this realm is always disrupted by new, emerging technologies and standards. Home is a dynamic environment which constantly grows and evolves. To keep up with changes, home automation algorithms are tweaked and modified over time. To tackle diversity, we employ model driven approaches to weave different technologies and facilitate home automation tasks. We show how modelling techniques improve portability, scalability and simulation of the home automation features. We present two use-cases developed in cooperation with industry partners, report our experience in applying ThingML and the Arrowhead framework in the home automation domain.

Product derivation is a building process of products from selected features in software product lines (SPLs). Realisation paves the way for automatic product derivation. A realisation defines a mapping between abstract features in a feature tree and their implementation artefacts in a model, and therefore governs the derivation of a new product. We experience that a realisation is not always straightforward and robust against modifications in the model. In the paper, we introduce an approach to build robust realisations. It consists of automated planning techniques and a layered architecture to yield a product. We demonstrate how our approach can leverage modern means of software design, development and validation. We evaluate the approach on a use-case provided by an industry partner and compare our technique to the existing realisation layer in the Base Variability Resolution (BVR) language.

Dynamic Software Product Lines (DSPLs) offer a strategy to deal with software changes that need to be handled at run-time. In response to context changes, a DSPL capitalize on knowledge about the architecture variability of the software system to shift between configurations. Similar to any other kind of software, a DSPL needs to evolve over time but current approaches require software engineers to manually perform the DSPL evolution. Our work addresses the evolution of the architecture variability that makes up the knowledge of the DSPL. Given a new version of the architecture variability, we calculate its configuration space and propose strategies that allow migration from the current version to the new version. Our strategy solves the collision of the realization layer resulting from the integration of the new version of the variability specification. We evaluate our dynamic evolution strategy using the Goal-Question-Metric method for a Smart Hotel case study with 239 possible configurations as starting point. Our experiment indicates that the proposed technique would enable automatic evolution in 9 out of 10 cases. In the rest of the cases, all of the DSPL configurations changed between the old and the new version, which frustrates an automatic evolution.

Metamodels evolve over time, which can break the conformance between the models and the metamodel. Model migration strategies aim to co-evolve models and metamodels together, but their application is not fully automatizable and is thus cumbersome and error prone. We introduce the Variable MetaModel (VMM) strategy to address the evolution of the reusable model assets of a model-based Software Product Line. The VMM strategy applies variability modeling ideas to express the evolution of the metamodel in terms of commonalities and variabilities. When the metamodel evolves, the models continue to conform to the VMM, avoiding the need for migration. We have applied both the traditional migration strategy and the VMM strategy to a retrospective case study that includes 13 years of evolution of our industrial partner, an induction hobs manufacturer. The comparison between the two strategies shows better results for the VMM strategy in terms of model indirection, automation, and trust leak.

Software Product Lines (SPLs) can be established from a set of similar models. Establishing the Product Line by mechanically finding model differences may not be the best approach. The identified model fragments may not be seen as recognizable units by the application engineers. We propose to identify model patterns by human-in-the-loop and conceptualize them as reusable model fragments. The approach provides the means to identify and extract those model patterns and further apply them to existing product models. Model fragments obtained by applying our approach seem to perform better than mechanically found ones. It turns out that the repetition of a fragment does not guarantee its relevance as reusable asset for the SPL engineers and vice versa, a fragment that has not been repeated yet, may be relevant as a reusable asset. We have validated these ideas with our industrial partner BSH, an induction hobs manufacturer that generates the firmware of their products from a model-driven SPL.

The aim of domain engineering process is to define and realise the commonality and variability of a Software Product Line. In the context of a family of models, spotting the commonalities and differences may become cumbersome and error prone as the number of models and its complexity increases. This work presents an approach to automate the formalization of variability in a given family of models. As output, the variability is made explicit in terms of Common Variability Language. The model commonalities and differences are specified as placements over a base model and replacements in a model library. The resulting Software Product Line (SPL) enables the derivation of new product models by reusing the extracted model fragments. Furthermore, the SPL can be evolved by the creation of new models, which are in turn automatically decomposed as model fragments of the SPL. The approach has been validated with our industrial partner (BSH), an induction hobs company. Finally, we present five different evolution scenarios encountered during the validation.

The Base Variability Resolution (BVR) is a modern language to build software product lines (SPL). The language incorporates advanced concepts for feature modeling, reuse and realization of components in SPL. The BVR bundle implements and supports the language. The tool covers design, implementation and quality assurance to close the development cycle. The bundle enables feature modeling, resolution, realization and derivation of products, their testing and analysis. We integrate the SPLCA additions to provide the state of the art algorithms for analysis. The project is open-source and available for practitioners. The tool consists of Eclipse plug-ins which work seamlessly together as well as separate stand-alone components. We describe how the tool collaboration contributes to variability modeling. In addition, we present how the bundle applies well-known design patterns, principals to achieve synergy between components.

Variability management aims at taming variability in large and complex software product lines. To efficiently manage variability, it has to be modeled using formal representations, such as feature or decision models. Such models are efficient in many domains, where variability is about switching on and off features, or using parameters to customize products of the product line. However, variability can be represented in the form of a topology in domains where variability is about connecting components in a certain order, in specific interconnected hierarchies, or in different quantities.

The Common Variability Language (CVL) is a domain-independent language for specifying and resolving variability. It facilitates the specification and resolution of variability over any instance of any language defined using a MOF-based meta-model.

This paper presents a generic approach for automating the augmentation of product lines using model comparison and variability modeling techniques. Product lines are subject to frequent augmentation to include more products. Our approach aims to reduce manual effort involved in this process by automatically suggesting a tentative augmented product line model, which can serve as a baseline for the final product line. The Common Variability Language (CVL), a generic variability modeling language, is used to specify product lines in this approach. The approach applies CVL Compare, a generic approach for automating the synthesis of a CVL-based product line from a set of existing product models. The approach is illustrated with an example from a train control product line.

The tutorial will present the present the outcome of the work done by the Joint Submission Team against the Request For Proposals for a Common Variability Language issued by the OMG (Object Management Group). The tutorial will present the language and experiments done by some of the consortium members on tools supporting preliminary tools for CVL.

A scalable approach for software product line testing is required due to the size and complexity of industrial product lines. In this paper, we present a specialized algorithm (called ICPL) for generating covering arrays from feature models. ICPL makes it possible to apply combinatorial interaction testing to software product lines of the size and complexity found in industry. For example, ICPL allows pair-wise testing to be readily applied to projects of about 7,000 features and 200,000 constraints, the Linux Kernel, one of the largest product lines where the feature model is available. ICPL is compared to three of the leading algorithms for t-wise covering array generation. Based on a corpus of 19 feature models, data was collected for each algorithm and feature model when the algorithm could finish 100 runs within three days. These data are used for comparing the four algorithms. In addition to supporting large feature models, ICPL is quick, produces small covering arrays and, even though it is non-deterministic, produces a covering array of a similar size within approximately the same time each time it is run with the same feature model.

We show how the effort needed to verify a transformed base model can be reduced by analyzing the definition of the modification. The Common Variability Language (CVL) is a generic language for modeling variability, where a CVL model describes the increment from one base model to another (transformed) base model. Assuming that a property of the base model has been verified, we use the CVL model to reduce the effort needed to verify the property of the transformed model. Based on the CVL model, we narrow down the set of traces required to be verified, including the increment and the cascading effects. We apply CVL to several models of the Train Control Language (TCL) to illustrate how the effort of verifying safety properties of transformed train station models can be reduced.

Current model-driven software product line development is mostly based on feature/variability modeling techniques, however, we see the potential for automatic assistance in identifying the commonality and variability of a set of models within the domain and synthesizing the product line model based on those. This paper presents a generic approach for synthesizing a software product line using model comparison. For model difference detection, the approach applies EMF Compare, a generic model comparison tool. For specifying the variability, the approach applies the Common Variability Language (CVL), a generic language for expressing variability. The SPL developer starts with comparing the existing potential product models in order to identify reusable assets (model fragments). Our tool prototype CVL Compare detects the difference between the existing product models and performs higher-order comparisons to explore the commonality and variability of the domain. Based on the comparison results, a preliminary product line model (CVL model) can be automatically induced and the SPL developer may further enhance the product line model. The approach is illustrated with an example of train control product line.

We show how a common language of variability can be used to enhance the expressiveness of a Domain Specific Language (DSL). DSLs have been proposed as a mechanism for expressing variability. Variability between models in a given domain or of a family of systems is captured by language constructs, implying that all possible models in this language are the allowed variations. We explore the possibility of expressing variability in a language independently of the base modeling language. We explore how this works for small DSLs as well as for general purpose languages like UML. Implications of this approach are that the variability language can be standardized, and that DSLs do not have to include variability mechanisms.

An aspect-based extension to a text transformation language provides higher-order transformations that can be used to represent variability in generative product line engineering. We show by example how these higher-order transformations compare with first order transformations. We also detail how the approach has been implemented as an extension of MOFScript, an existing model-to-text transformation language.