Architectural evolution of FamiWare using cardinality-based feature models

ContextAmbient Intelligence systems domain is an outstanding example of modern systems that are in permanent evolution, as new devices, technologies or facilities are continuously appearing. This means it would be desirable to have a mechanism that helps with the propagation of evolution changes in deployed systems.ObjectiveWe present a software product line engineering process to manage the evolution of FamiWare, a family of middleware for ambient intelligence environments. This process drives the evolution of FamiWare middleware configurations using cardinality-based feature models, which are especially well suited to express the structural variability of ambient intelligence systems.MethodFamiWare uses cardinality-based feature models and clonable features to model the structural variability present in ambient intelligence systems, composed of a large variety of heterogeneous devices. Since the management evolution of configurations with clonable features is manually untreatable due to the high number of features, our process automates it and propagates changes made at feature level to the architectural components of the FamiWare middleware. This is a model driven development process as the evolution management, the propagation of evolution changes and the code generation are performed using some kind of model mappings and transformations. Concretely we present a variability modelling language to map the selection of features to the corresponding FamiWare middleware architectural components.ResultsOur process is able to manage the evolution of cardinality-based feature models with thousands of features, something which is not possible to tackle manually. Thanks to the use of the variability language and the automatic code generation it is possible to propagate and maintain a correspondence between the FamiWare architectural model and the code. The process is then able to calculate the architectural differences between the evolved configuration and the previous one. Checking these differences, our process helps to calculate the effort needed to perform the evolution changes in the customized products. To perform those tasks we have defined two operators, one to calculate the differences between two feature model configurations and another to create a new configuration from a previous one.ConclusionOur process automatically propagates the evolution changes of the middleware family into the existing configurations where the middleware is already deployed and also helps us to calculate the effort in performing the changes in every configuration. Finally, we validated our approach, demonstrating the functioning of the defined operators and showing that by using our tool we can generate evolved configurations for FamiWare with thousands of cloned features, for several case studies.     

Dynamic adaptation of service compositions with variability models

Web services run in complex contexts where arising events may compromise the quality of the whole system. Thus, it is desirable to count on autonomic mechanisms to guide the self-adaptation of service compositions according to changes in the computing infrastructure. One way to achieve this goal is by implementing variability constructs at the language level. However, this approach may become tedious, difficult to manage, and error-prone. In this paper, we propose a solution based on a semantically rich variability model to support the dynamic adaptation of service compositions. When a problematic event arises in the context, this model is leveraged for decision-making. The activation and deactivation of features in the variability model result in changes in a composition model that abstracts the underlying service composition. These changes are reflected into the service composition by adding or removing fragments of Business Process Execution Language (WS-BPEL) code, which can be deployed at runtime. In order to reach optimum adaptations, the variability model and its possible configurations are verified at design time using Constraint Programming. An evaluation demonstrates several benefits of our approach, both at design time and at runtime.     

The DOPLER meta-tool for decision-oriented variability modeling: a multiple case study

The variability of a product line is typically defined in models. However, many existing variability modeling approaches are rigid and don’t allow sufficient domain-specific adaptations. We have thus been developing a flexible and extensible approach for defining product line variability models. Its main purposes are to guide stakeholders through product derivation and to automatically generate product configurations. Our approach is supported by the DOPLER (Decision-Oriented Product Line Engineering for effective Reuse) meta-tool that allows modelers to specify the types of reusable assets, their attributes, and dependencies for their specific system and context. The aim of this paper is to investigate the suitability of our approach for different domains. More specifically, we explored two research questions regarding the implementation of variability and the utility of DOPLER for variability modeling in different domains. We conducted a multiple case study consisting of four cases in the domains of industrial automation systems and business software. In each of these case studies we analyzed variability implementation techniques. Experts from our industry partners then developed domain-specific meta-models, tool extensions, and variability models for their product lines using DOPLER. The four cases demonstrate the flexibility of the DOPLER approach and the extensibility and adaptability of the supporting meta tool.     

Investigating the Effect of Software Packaging on Modular Structure Stability

In object-oriented development, packages form the basic modular structural components of large-scale software systems. Packaging processes aim to group classes together to provide well-identified functions/services to the rest of the system. In this context, it is widely believed that packaging quality has an influence on the software stability so that it should be useful predictors for modular structural stability. In this paper, we investigate the effect of packaging configurations on the modular structure stability of object-oriented systems. Using genetic algorithms, we conducted a series of experiments to find the relation between the packaging quality and modular structure stability. We conducted experiments on open source systems using an automatic packaging approach recently proposed by the authors. Results show that the stability of releases automatically packaged using that approach was better or at least comparable to those of the corresponding original releases manually packaged by the software developers. Moreover, the different parameters settings of the genetic algorithms used in our experiments play an important role to improve the overall quality. The experimental results suggest that the considered packaging approach is useful for practitioners to develop architecturally stable software systems.     

Visualization of variability and configuration options

When designing, constructing, and maintaining diverse and variable software systems, a key challenge is the complexity of systems. A potential approach to tackle this challenge are techniques from variability management and product line engineering to handle the diversity and variability. A key asset in variability management is a variability model, which explicitly specifies the commonalities and variability of a system and the constraints between variants. However, handling variability and configurations remains a challenge due to the complexity on a cognitive level as human engineers reach their limits in identifying, understanding, and using all relevant details. In this paper we address this issue by providing concepts for interactive visual tool support for the configuration of systems with the help of feature models. We discuss relevant principles from the area of information visualization and their application to the domain of feature model configuration. We discuss techniques for interactive configuration support based on a reasoning engine, which, e.g., ensures the validity of configurations. We illustrate our findings by a concrete tool solution called S2T2 Configurator.     

A feature-oriented approach for developing reusable product line assets of service-based systems

Service orientation (SO) is a relevant promising candidate for accommodating rapidly changing user needs and expectations. One of the goals of adopting SO is the improvement of reusability, however, the development of service-based system in practice has uncovered several challenging issues, such as how to identify reusable services, how to determine configurations of services that are relevant to users’ current product configuration and context, and how to maintain service validity after configuration changes. In this paper, we propose a method that addresses these issues by adapting a feature-oriented product line engineering approach. The method is notable in that it guides developers to identify reusable services at the right level of granularity and to map users’ context to relevant service configuration, and it also provides a means to check the validity of services at runtime in terms of invariants and pre/post-conditions of services. Moreover, we propose a heterogeneous style based architecture model for developing such systems.     

Adaptive smart card-based pull control systems in context-aware manufacturing systems: Training a neural network through multi-objective simulation optimization

Nowadays, context aware manufacturing systems offer interesting capabilities to improve the performance of pull controlled production systems. Smart Kanbans can be used instead of physical cards, and the information become available about the production context, collected for example through sensors and RFID. Such information can be exploited by intelligent pull control strategies so as to dynamically adapt the number of cards. This is particularly useful for production systems that are subjected to unpredictable changes in the customers’ demand, and need to react quickly to preserve a high level of performance. For this reason, we aim, in this article, at proposing an intelligent system, which can communicate with the information system, whose purpose is to autonomously decide or to help managers in adding or removing cards. In this respect, we propose an approach that uses a neural network which is trained offline, directly from simulation, to decide when it is relevant to change the number of cards, and at what production stage. The learning process, based on multi-objective simulation optimization, aims at reducing the production costs as well as the number of changes to avoid nervousness. The use of stochastic simulation, allows various types of complex problems, related to manufacturing systems, to be addressed and fluctuating demand phenomena to be taken into account. The relevance of our approach is illustrated using six published adaptive ConWIP and Kanban systems. Comparisons with adaptive Kanban and ConWIP systems show that the neural network can automatically learn very relevant knowledge. Good results are obtained in terms of performance, with fewer changes in the number of cards. Several possible future research directions are pointed out.     

Minimization of cost,sediment load,and sensitivity to climate change in a watershed management application

One challenge of climate change adaptation is to design watershed-based stormwater management plans that meet current total maximum daily load targets and also take into consideration anticipated changes in future precipitation patterns. We present a multi-scale, multiobjective framework for generating a diverse family of stormwater best management practice (BMP) plans for entire watersheds. Each of these alternative BMP configurations are non-dominated by any other identified solution with respect to cost of the implementation of the management plan and sediment loading predicted at the outflow of the watershed; those solutions are then pruned with respect to dominance in sensitivity to predicted changes in precipitation patterns. We first use GIS data to automatically precompute a set of cost-optimal BMP configurations for each subwatershed, over its entire range of possible treatment levels. We then formulate each solution as a real-valued vector of treatment levels for the subwatersheds and employ a staged multiobjective optimization approach using differential evolution to generate sets of non-dominated solutions. Finally, selected solutions are mapped back to the corresponding preoptimized BMP configurations for each subwatershed. The integrated method is demonstrated on the Bartlett Brook mixed-used impaired watershed in South Burlington, VT, and patterns in BMP configurations along the non-dominated front are investigated. Watershed managers and other stakeholders could use this approach to assess the relative trade-offs of alternative stormwater BMP configurations.     

Supporting runtime software architecture: A bidirectional-transformation-based approach

Runtime software architectures (RSA) are architecture-level, dynamic representations of running software systems, which help monitor and adapt the systems at a high abstraction level. The key issue to support RSA is to maintain the causal connection between the architecture and the system, ensuring that the architecture represents the current system, and the modifications on the architecture cause proper system changes. The main challenge here is the abstraction gap between the architecture and the system. In this paper, we investigate the synchronization mechanism between architecture configurations and system states for maintaining the causal connections. We identify four required properties for such synchronization, and provide a generic solution satisfying these properties. Specifically, we utilize bidirectional transformation to bridge the abstraction gap between architecture and system, and design an algorithm based on it, which addresses issues such as conflicts between architecture and system changes, and exceptions of system manipulations. We provide a generative tool-set that helps developers implement this approach on a wide class of systems. We have successfully applied our approach on JOnAS JEE system to support it with C2-styled runtime software architecture, as well as some other cases between practical systems and typical architecture models.     

Towards Software Architecture and Mechanisms for Improving Runtime Variability of Internetware System

As an emerging software paradigm, Internetware is proposed to handle openness, dynamism of software systems in the context of Internet, which implies that such software systems typically have runtime variability that can be improved dynamically to handle various or even unexpected changes of requirements and open environment. Though many progresses of Internetware software technologies have been made to support the adaptation, evolution, context-awareness, etc. of Internetware, how to construct Internetware systems with the ability to improve their runtime variability is still a great challenge in the literature of software engineering. In this paper, we propose software architecture and mechanisms for Internetware systems to support the improvement of their runtime variability by combining software variability and autonomic computing techniques. The Internetware system is organized as three levels that are consist of variable autonomic elements and Internetware entities, and architecture of these software entities is defined and discussed respectively. Moreover, we put forward a series of runtime mechanisms based on these levels, including module selection, intermediator and horizontal management, to realize operations upon the variation points and variants in software architectures and thus achieve the improvement of runtime variability. We develop a sample of Personal Data Resource Network to depict the requirements and scenario of improving runtime variability, and further study the case based on our proposed approach to show its effectiveness and applicability.     

Regular Model Checking Using Inference of Regular Languages

Regular model checking is a method for verifying infinite-state systems based on coding their configurations as words over a finite alphabet, sets of configurations as finite automata, and transitions as finite transducers. We introduce a new general approach to regular model checking based on inference of regular languages. The method builds upon the observation that for infinite-state systems whose behaviour can be modelled using length-preserving transducers, there is a finite computation for obtaining all reachable configurations up to a certain length n. These configurations are a (positive) sample of the reachable configurations of the given system, whereas all other words up to length n are a negative sample. Then, methods of inference of regular languages can be used to generalize the sample to the full reachability set (or an overapproximation of it). We have implemented our method in a prototype tool which shows that our approach is competitive on a number of concrete examples. Furthermore, in contrast to all other existing regular model checking methods, termination is guaranteed in general for all systems with regular sets of reachable configurations. The method can be applied in a similar way to dealing with reachability relations instead of reachability sets too.     

An agent-oriented approach to change propagation in software maintenance

Software maintenance and evolution is a lengthy and expensive phase in the life cycle of a software system. In this paper we focus on the change propagation problem: given a primary change that is made in order to meet a new or changed requirement, what additional, secondary, changes are needed? We propose a novel, agent-oriented, approach that works by repairing violations of desired consistency rules in a design model. Such consistency constraints are specified using the Object Constraint Language (OCL) and the Unified Modelling Language (UML) metamodel, which form the key inputs to our change propagation framework. The underlying change propagation mechanism of our framework is based on the well-known Belief-Desire-Intention (BDI) agent architecture. Our approach represents change options for repairing inconsistencies using event-triggered plans, as is done in BDI agent platforms. This naturally reflects the cascading nature of change propagation, where each change (primary or secondary) can require further changes to be made. We also propose a new method for generating repair plans from OCL consistency constraints. Furthermore, a given inconsistency will typically have a number of repair plans that could be used to restore consistency, and we propose a mechanism for semi-automatically selecting between alternative repair plans. This mechanism, which is based on a notion of cost, takes into account cascades (where fixing the violation of a constraint breaks another constraint), and synergies between constraints (where fixing the violation of a constraint also fixes another violated constraint). Finally, we report on an evaluation of the approach, covering effectiveness, efficiency and scalability.     

Precise gouging-free tool orientations for 5-axis CNC machining

We present a precise approach to the generation of optimized collision-free and gouging-free tool paths for 5-axis CNC machining of freeform NURBS surfaces using flat-end and rounded-end (bull nose) tools having cylindrical shank. To achieve high approximation quality, we employ analysis of hyper-osculating circles (HOCs) (Wang et al., 1993a,b), that have third order contact with the target surface, and lead to a locally collision-free configuration between the tool and the target surface. At locations where an HOC is not possible, we aim at a double tangential contact among the tool and the target surface, and use it as a bridge between the feasible HOC tool paths. We formulate all such possible two-contact configurations as systems of algebraic constraints and solve them. For all feasible HOCs and two-contact configurations, we perform a global optimization to find the tool path that maximizes the approximation quality of the machining, while being gouge-free and possibly satisfying constraints on the tool tilt and the tool acceleration. We demonstrate the effectiveness of our approach via several experimental results.     

Algorithms for generating multi-stage molding plans for articulated assemblies

Multi-stage molding is capable of producing better-quality articulated products at a lower cost. During the multi-stage molding process, assembly operations are performed along with the molding operations. Hence, it gives rise to a new type of planning problem. It is difficult to perform the planning manually because it involves evaluating large number of combinations and solving complex geometric reasoning problems. This paper investigates the problem of generating multi-stage molding plans for articulated assemblies. We present a planning framework that allows us to utilize constraints from experimentally proven molding plans. As a part of the planning problem, we determine the molding sequence and intermediate assembly configurations. We present algorithms for all the steps in the planning problem and characterize their computational complexities. Finally, we illustrate our approach with representative examples.     

A behavioral reflective architecture for managing the integration of personal ubicomp systems: automatic SNMP-based discovery and management of behavior context in smart-spaces

Context-aware ubiquitous computing systems should be able to introspect the surrounding environment and adapt their behavior according to other existing systems and context changes. Although numerous ubiquitous computing systems have been developed that are aware of different types of context such as location, social situation, and available computational resources, few are aware of their computational behavior. Computational behavior introspection is common in reflective systems and can be used to improve the awareness and autonomy of ubicomp systems. In this paper, we propose a decentralized approach based on Simple Network Management Protocol (SNMP) and Universal Plug and Play (UPnP), and on state transition models to model and expose computational behavior. Typically, SNMP and UPnP are targeted to retrieve raw operational variables from managed network devices and consumer electronic devices, e.g., checking network interface bandwidth and automating device discovery and plug and play operations. We extend the use of these protocols by exposing the state of different ubicomp systems and associated state transitions statistics. This computational behavior may be collected locally or remotely from ubicomp systems that share a physical environment, and sent to a coordinator node or simply shared among ubicomp systems. We describe the implementation of this behavior awareness approach in a home health-care environment equipped with a VoIP Phone and a drug dispenser. We provide the means for exposing and using the behavior context in managing a simple home health-care setting. Our approach relies on a system state specification being provided by manufacturers. In the case where the specification is not provided, we show how it can be automatically discovered. We propose two machine learning approaches for automatic behavior discovery and evaluate them by determining the expected state graphs of our two systems (a VoIP Phone and a drug dispenser). These two approaches are also evaluated regarding the effectiveness of generated behavior graphs.     

Extending BDI plan selection to incorporate learning from experience

An important drawback to the popular Belief, Desire, and Intentions (BDI) paradigm is that such systems include no element of learning from experience. We describe a novel BDI execution framework that models context conditions as decision trees, rather than boolean formulae, allowing agents to learn the probability of success for plans based on experience. By using a probabilistic plan selection function, the agents can balance exploration and exploitation of their plans. We extend earlier work to include both parameterised goals and recursion and modify our previous approach to decision tree confidence to include large and even non-finite domains that arise from such consideration. Our evaluation on a pre-existing program that relies heavily on recursion and parametrised goals confirms previous results that naive learning fails in some circumstances, and demonstrates that the improved approach learns relatively well.     

Structuring the modeling space and supporting evolution in software product line engineering

The scale and complexity of product lines means that it is practically infeasible to develop a single model of the entire system, regardless of the languages or notations used. The dynamic nature of real-world systems means that product line models need to evolve continuously to meet new customer requirements and to reflect changes of product line artifacts. To address these challenges, product line engineers need to apply different strategies for structuring the modeling space to ease the creation and maintenance of models. This paper presents an approach that aims at reducing the maintenance effort by organizing product lines as a set of interrelated model fragments defining the variability of particular parts of the system. We provide support to semi-automatically merge fragments into complete product line models. We also provide support to automatically detect inconsistencies between product line artifacts and the models representing these artifacts after changes. Furthermore, our approach supports the co-evolution of models and their respective meta-models. We discuss strategies for structuring the modeling space and show the usefulness of our approach using real-world examples from our ongoing industry collaboration.     

Model-driven agent-based simulation development: A modeling language and empirical evaluation in the adaptive traffic signal control domain

Model-driven development (MDD) is an approach for supporting the development of software systems, in which high-level modeling artifacts drive the production of time and effort-consuming low-level artifacts, such as the source code. Previous studies of the MDD effectiveness showed that it significantly increases development productivity, because the development effort is focused on the business domain rather than technical issues. However, MDD was exploited in the context of agent-based development in a limited way, and most of the existing proposals demonstrated the effectiveness of using MDD in this context by argumentation or examples, lacking disciplined empirical analyses. In this paper, we explore the use of MDD for agent-based modeling and simulation in the adaptive traffic signal control (ATSC) domain, in which autonomous agents are in charge of managing traffic light indicators to optimize traffic flow. We propose an MDD approach, composed of a modeling language and model-to-code transformations for producing runnable simulations automatically. In order to analyze the productivity gains of our MDD approach, we compared the amount of design and implementation artifacts produced using our approach and traditional simulation platforms. Results indicate that our approach reduces the workload to develop agent-based simulations in the ATSC domain.