Abstract: In model-driven engineering, modeling languages are developed to serve as basis for system design, simulation and code generation. Like any software artifact, modeling languages evolve over time. If, however, the metamodel that defines the language is badly designed, the effort needed for its maintenance is unnecessarily increased. In this paper, we present bad smells and anti-patterns that we discovered in a thorough metamodel review of the Palladio Component Model (PCM). The PCM is a good representative for big and old metamodels that have grown over time. Thus, these results are meaningful, as they reflect the types of smells that accumulate in such metamodels over time. Related work deals mainly with automatically detectable bad smells, anti-patterns and defects. However, there are smells and anti-patterns, which cannot be detected automatically. They should not be neglected. Thus, in this paper, we focus on both: automatically and non-automatically detectable smells.

Abstract: The Pipe-and-Filter style represents a well-known family of component-based architectures. By executing each filter on a dedicated processing unit, it is also possible to leverage contemporary distributed systems and multi-core systems for a high throughput. However, this simple parallelization approach is not very effective when (1) the workload is uneven distributed over all filters and when (2) the number of available processing units exceeds the number of filters. In the first case, parallelizing all filters can lead to a waste of resources since only the slowest filter is responsible for the overall throughput. In the second case, some processing units remain unused. In this paper, we present an automatic parallelization approach providing high throughput and utilizing the available processing units. Our main idea is to provide a composite filter that is wrapped around an existing filter to increase its throughput. We call this composite filter the Task Farm Filter since it implements the Task Farm parallelization pattern. It creates and executes multiple instances of the underlying filter in parallel. Moreover, we present a modular, self-adaptive mechanism that automatically adapts the number of instances at runtime to achieve the highest possible throughput. Finally, we present an extensive experimental evaluation of our self-adaptive task farm filter by employing a CPU-intensive, an I/O-intensive, and a hybrid scenario. The evaluation shows that our task farm automatically parallelize the underlying filter and thus increases the overall throughput. Furthermore, the evaluation shows that our task farm scales well with the workload of the executed Pipe-and-Filter architecture.

Abstract: The Internet of Things (IoT) embeds sensors, actuators and computation into everyday 'things' such as lights and thermostats. These things form low-power wireless networks connecting to the Internet via IPv6 for monitoring and control. Such IoT systems are increasingly subject to runtime reconfiguration, wherein new hardware and software may be installed dynamically to accommodate changing application objectives. Supporting runtime reconfiguration, while maintaining reliability and low-power operation requires cross-layer optimisation of network resources. This paper introduces Dawn, a network optimisation approach for component-based systems that automatically extracts and enforces bandwidth requirements from component compositions. Dawn allows application developers to build extremely flexible and yet dependable IoT networks. We implemented a prototype of Dawn for a 50-node testbed composed of state-of-the-art embedded IoT devices. Our evaluation shows that Dawn preserves 100% end-to-end reliability in the face of network reconfiguration, while extending battery lifetime three-fold compared to a one-size-fits-all network configuration with minimal memory and performance overhead.

Abstract: Nowadays, the average users owns two or more Web-enabled devices (smart phones, personal computers and tablets), while more are coming: watches, cars, glasses. While responsive Web applications can adapt to the specific device (e.g., screen size or input method) on which they are deployed, they only provide limited support when one user connects from more than one device at the same time. In this paper we present Liquid.js for Polymer, a framework whose goal is to support developers that need to build liquid Web applications taking full advantage of multiple heterogeneous devices. It extends emerging Web components standards to enable the liquid user experience, whereby any device can be used sequentially or concurrently with applications that can roam from one device to another with no effort required by users controlling them. This way, users do not need to stop and resume their work on their Web application as they switch devices. Developers using Liquid.js for Polymer do not need to worry about the underlying connectivity, pairing and synchronization issues of their stateful Web components.

Abstract: The component-based software architecture of a cyber-physical system (CPS) is often subject to structural reconfigurations in response to changing environmental conditions. When introducing reconfigurations to CPS, it is mandatory to ensure that the execution of a reconfiguration does not compromise the safety of the system, e.g., by causing a violation of hard real-time constraints. Existing approaches for ensuring safe reconfiguration do not consider such hard realtime constraints or the interaction of a CPS with its physical environment. Thus, they can not detect all relevant unsafe situations. In this paper, we introduce a novel approach that is based on a design-time specification of conditions for unsafe states combined with a runtime evaluation of these conditions. This enables to detect all relevant unsafe states with respect to a requested reconfiguration at runtime. We illustrate our approach based on a smart railway system.

Abstract: In software product line engineering, the construction of an ADL architecture for a product family is still an outstanding engineering challenge. An ADL architecture for a product family would define the architectures for all the products in the family, allowing engineers to reason at a higher level of abstraction. In this paper, we outline a component model that can be used to define architectures for product families, by incorporating explicit variation points.

Abstract: To support the complex functionality expected of modern embedded systems, the trend is to supplement CPUs with Graphical Processing Units (GPUs), thus creating heterogeneous embedded systems. However, taking full advantage of GPUs increases the complexity of the development and requires dedicated support, and no such support exists in the component models currently available. The only solution today is to completely encapsulate all GPU-specific information and operations within the components, which increases the communication overhead and reduces component reusability, thus significantly limiting the applicability of component-based development to heterogeneous embedded systems. In this paper, we propose to extend Rubus, an industrial component model for embedded systems, with dedicated support for GPUs. We introduce new constructs, including GPU ports and automatically generated adapters to facilitate seamless component communication over the heterogeneous processing units, regardless of whether the components use the CPU, GPU, or both. A running example is used for the problem description, the proposed extension, and to evaluate our solution.

Abstract: Architectural component models play a crucial role in achieving the desired software quality, as understandability of components and their interactions plays a key role in supporting the architectural understanding of a software system. In this article, we extend our previous studies on component models understandability. Our extensions study hierarchical understandability metrics, the impact of personal factors of participants like experience and expertise, and the combinations of both personal factors and the metrics (the previously studied and the newly introduced). The subjects of the study had to fully understand the functionalities of a number of components of an open source system by exploring the relationships of the components' classes. Our results provide evidence that the hierarchical understandability metrics are significantly better in predicting the understandability effort than the models obtained in our previous studies or the models that include just the participants' experiences. The participants' experience plays an important role in the prediction but the obtained prediction models are not as accurate as the models that use the component level metrics.

Abstract: Modern embedded systems utilize the advances in heterogeneous platforms that enable implementing functions in software (SW) and hardware (HW) components. A proper configuration of SW and HW components can significantly improve the values of the extra-functional properties such as performance and energy savings. However, due to increasing application complexity, it is difficult to find the best combination of HW and SW components. The problem basically boils down to calculate, for a given architecture, the system properties from the components' ones. In this paper, we address the problem of composability of EFPs at system level. Although in general this is not a solvable problem, we present that, under strictly specified constraints, it is possible to compose the system EFPs starting from the component ones. We start by detailing constraints related to the system architecture, platform and process development and, based on these constraints, we provide composition rules for different types of EFPs. We demonstrate the results through an industrial example.

Abstract: The architecture of classic productivity software are moving from a traditional desktop-based software to a client server architecture hosted in the Cloud. In this context, web browsers behave as application containers that allow users to access a variety of Cloud-based applications and services, such as IDEs, Word processors, Music Collection Managers, etc. As a result, a significant part of these software run in the browser and accesses remote services. A lesson learned from development framework used in distributed applications is the success of pluggable architecture pattern as a core architecture concept, i.e., a Software Architecture that promotes the use of Pluggable Module to dynamically plug. Following this trend, this paper discusses the main challenges to create a component-based platform supporting the development of dynamically adaptable single web page applications. This paper also presents an approach called KevoreeJS based on models@runtime to control browser as component platform which address some of these challenges. We validate this work by presenting the design of a dashboard for sensor based system and highlighting the capacity of KevoreeJS to dynamically choose the placement of code on the server or client side and how KevoreeJS can be used to dynamically install or remove running components.

Abstract: A large majority of existing software development approaches in the vehicle industrial domain have a limited or no modeling support to fully reuse legacy nodes at the highest abstraction, called the vehicle level. In this paper, we introduce a new technique for model-and component-based development of vehicular distributed embedded systems at the vehicle level. The proposed technique supports not only modeling of crude nodes or Electronic Control Units but also modeling of legacy nodes whose software architectures can be partially or completely reused. As a proof of concept, we implement the modeling technique in an industrial model, the Rubus Component Model. In order to show the usability of our approach, we model a vehicular application using the extended component model and its tool suite.

Abstract: Big Data aims at the efficient processing of massive amounts of data. Performance modeling is often used to optimize performance of systems under development. Based on experiences from modeling Big Data solutions, we describe some problems in applying performance modeling and discuss potential solution approaches.

Abstract: While designing dependable systems, a large number of asset combinations (system configurations) with contrary quality objectives needs to be investigated. Basically, each feasible configuration should be investigated. For fault-tolerant embedded systems this problem is extended by anticipating hardware faults leading to changed deployments of stressed resources in redundant constellations. The identification and evaluation of the best-fitting configuration remains a computationally intensive and difficult task at all. We propose a multi-stage approach (1) to sample Paretooptimal configurations for redundant system designs within hostile environments, (2) to check satisfiability of structural constraints and (3) to measure and identify quality degradation in fault scenarios. Thus, allowing developers to identify design flaws, leading to large quality degradations in case of emerging faults. We use genetic algorithms (NSGA-II) for sampling a wide range of system designs and demonstrate our approach by means of an exemplary fault-tolerant system.

Abstract: Component-based software engineering (CBSE) is based on defining, implementing and composing loosely coupled, independent components, thus increasing modularity, analyzability, separation of concerns and reuse. However, complete separation of concerns is difficult to achieve in CBSE when concerns crosscut several components. Furthermore, in some cases, reuse of components is limited because component developers make certain implementation choices that are incompatible with the non-functional requirements of the application that is being built. In this paper we outline how to integrate CBSE and concern-oriented reuse (CORE), a novel reuse paradigm that extends Model-Driven Engineering (MDE) with best practices from aspect-oriented software composition and Software Product Lines (SPL). Concretely, we outline how to combine the Palladio Component Model (PCM) capable of expressing complex software architectures with CORE class and sequence diagrams for low-level design. As a result, multiple solutions for addressing concerns that might even crosscut component boundaries can be modularized in a reusable way, and integrated with applications that reuse them using aspect-oriented techniques. Additionally, thanks to CORE, component developers can avoid premature decision making when reusing existing libraries during implementation.

Abstract: Component-based systems are often comprised of a large number of components, as well as services for binding them together. Static visualization of component dependencies suffers from scalability issues, due to the high number of nodes and edges, despite the fact that there have been previous approaches to mitigate this problem through diagram cluttering reduction mechanisms. Another limitation of static visualization is the inability to represent bindings that are dynamically determined at runtime. In this paper, we describe VISCTE, a tool for exploring component collaborations through runtime monitoring. We target concept location at the component level, where a user-controlled recording process enables developers to obtain diagrams that depict a partial representation of the system. We materialized the approach for OSGi-based component systems and successfully experimented it with an industrial-scale component-based system.

Abstract: By focussing on Cyber Physical Systems (CPS), this paper investigates how component-based principles and practices are used and support the activity of architecting CPS. For doing so, by running a systematic process, we selected 49 primary studies from the most important publishers search engines. Those papers have been analyzed and their contents classified according to the Classification Framework for Component Models proposed in our previous work. The results show that the main concerns handled by CPS component models are those of integration, performance, and maintainability. The instruments to satisfy those concerns, while architecting CPS, are ad-hoc software/system architecture, model-based approaches, architectural and component languages, and design. The IEC 61499 standard with its functions block is remarkably used to drive the work on six papers. Java is the most frequently used programming language used for implementing the components. Components are deployed mostly at compile time. Interfaces are almost equally distributed into port-based and operation-based. Overall, the results show a transition of technologies and approaches used in Embedded Systems to CPS, but still lacking methods for integrated architecting, in particular in incremental development.

Abstract: Modern software-based services increasingly rely on a highly heterogeneous and dynamic interconnection of platforms and devices offering a wide diversity of capabilities ranging from cloud server with virtually unlimited resources down to microcontrollers with only a few KB of RAM. This paper motivates the fact that no single software framework or software engineering approach is suited to span across this range, and proposes an approach which leverages the latest advances in model-driven engineering, generative techniques and models@runtime in order to tame this tremendous heterogeneity. This paper presents a set of languages dedicated to the integration, deployment and continuous operation of existing libraries and components already available and implemented in various languages. The proposed approach is validated on an industrial case study in the eHealth domain, implemented by an industrial partner that provide an qualitative evaluation of the approach. This case study involves a large number of sensors, devices and gateways based on Rasperry Pi, Intel Edison and Arduino.