Nadia Gámez

FamiWare: a family of event-based middleware for ambient intelligence

Most of the middlewares currently available focus on one type of device (e.g., TinyOS sensors) and/or are designed with one requirement in mind (e.g., data management). This is an important limitation since most of the AmI applications work with several devices (such as sensors, smartphones or PDAs) and use a high diversity of low-level services. Ideally, the middleware should provide a single interface for accessing all those services able to work in heterogeneous devices. To address this issue, we propose a family of configurable middleware (FamiWare) with a really flexible architecture, instead of building a single version of a middleware with a rigid structure. In this work, we present the architecture of our middleware that can be configured, following a Software Product Line approach, in order to be instantiated in a particular device fulfilling specific application requirements. Furthermore, we evaluate that the decisions taken at architecture and implementation are the adequate ones for this kind of constrained devices.

Autonomic computing driven by feature models and architecture in FamiWare

A wireless sensor network is an example of a system that should be able to adapt its sensor nodes to some context changes with minimum human intervention. This means that the architecture of the middleware for sensors must encapsulate a dynamic mechanism to allow reconfiguration. We present a novel approach to achieve self-adaptation based on software product lines and on the autonomic computing paradigm for the FamiWare middleware. FamiWare uses feature models to represent the potential middleware configurations at runtime. Each configuration is automatically mapped to the corresponding architectural representation of a specific middleware product. Following the autonomic computing principles, FamiWare defines a reconfiguration mechanism that switches from one architectural configuration to another by means of executing a plan. This is possible thanks to the loosely coupled architecture of FamiWare based on an event-based publish and subscribe mechanism. We evaluate our work by showing that the resource consumption and the overhead are not so critical compared with the benefits of providing this self-adaptation mechanism.

Architectural evolution of FamiWare using cardinality-based feature models

Context: Ambient 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. Objective: We 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. Method: FamiWare 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. Results: Our 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. Conclusion: Our 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.

Software product line evolution with cardinality-based feature models

Feature models are widely used for modelling variability present in a Software Product Line family. We propose using cardinality-based feature models and clonable features to model and manage the evolution of the structural variability present in pervasive systems, composed by a large variety of heterogeneous devices. The use of clonable features increases the expressiveness of feature models, but also greatly increases the complexity of the resulting configurations. So, supporting the evolution of product configurations becomes an intractable task to do it manually. In this paper, we propose a model driven development process to propagate changes made in an evolved feature model, into existing configurations. Furthermore, our process allows us to calculate the effort needed to perform the evolution changes in the customized products. To do this, we have defined two operators, one to calculate the differences between two configurations and another to create a new configuration from a previous one. Finally, we validate our approach, showing that by using our tool support we can generate new configurations for a family of products with thousands of cloned features.

Variabilities of Wireless and Actuators Sensor Network Middleware for Ambient Assisted Living

Wireless and Actuators Sensor Networks (WSANs) are one of the key technologies for supporting many Ambient Assisted Living applications. WSAN applications development poses new challenges like dealing with diverse low-level programming abstractions and the heterogeneity of nodes with critical resource limitations. Middleware platforms can hide from final developers the complexity of managing different types of hardware and software variability by applying a Software Product Line approach. This paper proposes a family of middleware for WSANs that can be customized according to the constraints imposed by the particular device, network and applications.

Composition and Self-Adaptation of Service-Based Systems with Feature Models

The adoption of mechanisms for reusing software in pervasive systems has not yet become standard practice. This is because the use of pre-existing software requires the selection, composition and adaptation of prefabricated software parts, as well as the management of some complex problems such as guaranteeing high levels of efficiency and safety in critical domains. In addition to the wide variety of services, pervasive systems are composed of many networked heterogeneous devices with embedded software. In this work, we promote the safe reuse of services in service-based systems using two complementary technologies, Service-Oriented Architecture and Software Product Lines. In order to do this, we extend both the service discovery and composition processes defined in the DAMASCo framework, which currently does not deal with the service variability that constitutes pervasive systems. We use feature models to represent the variability and to self-adapt the services during the composition in a safe way taking context changes into consideration. We illustrate our proposal with a case study related to the driving domain of an Intelligent Transportation System, handling the context information of the environment.

Configuring a Context-Aware Middleware for Wireless Sensor Networks

In the Future Internet, applications based on Wireless Sensor Networks will have to support reconfiguration with minimum human intervention, depending on dynamic context changes in their environment. These situations create a need for building these applications as adaptive software and including techniques that allow the context acquisition and decisions about adaptation. However, contexts use to be made up of complex information acquired from heterogeneous devices and user characteristics, making them difficult to manage. So, instead of building context-aware applications from scratch, we propose to use FamiWare, a family of middleware for Ambient Intelligence specifically designed to be aware of contexts in sensor and smartphone devices. It provides both, several monitoring services to acquire contexts from devices and users, and a context-awareness service to analyze and detect context changes. However, the current version of FamiWare does not allow the automatic incorporation related to the management of new contexts into the FamiWare family. To overcome this shortcoming, in this work, we first present how to model the context using a metamodel to define the contexts that must to be taken into account in an instantiation of FamiWare for a certain Ambient Intelligence system. Then, to configure a new context-aware version of FamiWare and to generate code ready-to-install within heterogeneous devices, we define a mapping that automatically transforms metamodel elements defining contexts into elements of the FamiWare family, and we also use the FamiWare configuration process to customize the new context-aware variant. Finally, we evaluate the benefits of our process, and we analyze both that the new version of the middleware works as expected and that it manages the contexts in an efficient way.

Aspect-Oriented Executable UML Models for Context-Aware Pervasive Applications

Pervasive applications must be aware of the contexts where they are executed. These contexts may vary greatly from each other and may change quickly. Thus, pervasive applications should be highly reconfigurable in order to deal with such context changes. There are two main problems associated with this issue: (1) context- awareness is a crosscutting concern that can not be well- encapsulated in a single module using traditional technologies, which hinders application design maintenance and reusability; and (2) reasoning about application design correctness can be complex due to the number and diversity of potential contexts where a pervasive application could be executed. In order to overcome these problems we propose the use of the aspect-oriented executable modelling (AOEM) UML 2.0 Profile for designing pervasive applications. Aspect-oriented techniques contribute to the encapsulation of crosscutting concerns, such as context- awareness, into well-localized modules. Executable Modelling helps engineers to reason about application design by executing the design models in different contexts and situations. Finally, we will discuss how these aspect-oriented models would map into a middleware platform that provides built-in services to support pervasive applications. Services, such as context-awareness, are provided as a set of user-configurable aspects. These ideas are illustrated using a location-aware intelligent transportation system consisting of a set of cooperating sentient vehicles.

Creating Self-Adapting Mobile Systems with Dynamic Software Product Lines

Mobile systems must cope with continuous context changes, making them an ideal fit with dynamic software product lines (DSPLs), which enable product adaptation at run time. In this DSPL-based process, devices upload only a small reconfiguration plan rather than the entire variability model, and providers manage diversity without disrupting the base model.

Dynamic reconfiguration of security policies in wireless sensor networks.

Providing security and privacy to wireless sensor nodes (WSNs) is very challenging, due to the heterogeneity of sensor nodes and their limited capabilities in terms of energy, processing power and memory. The applications for these systems run in a myriad of sensors with different low-level programming abstractions, limited capabilities and different routing protocols. This means that applications for WSNs need mechanisms for self-adaptation and for self-protection based on the dynamic adaptation of the algorithms used to provide security. Dynamic software product lines (DSPLs) allow managing both variability and dynamic software adaptation, so they can be considered a key technology in successfully developing self-protected WSN applications. In this paper, we propose a self-protection solution for WSNs based on the combination of the INTER-TRUST security framework (a solution for the dynamic negotiation and deployment of security policies) and the FamiWare middleware (a DSPL approach to automatically configure and reconfigure instances of a middleware for WSNs). We evaluate our approach using a case study from the intelligent transportation system domain.