Gaëtan Rey

Foundations for a Theory of Contextors

This article proposes an operational definition of the notion of context for the design and development of context-sensitive systems. Our definition draws upon the distinction between the notion of an instant snapshot of observables (a situation) and the composition of these observables over time (a context). Observables and their relationships, which are elicited at the design stage of the development process, can be mapped, at the implementation phase, as colonies of contextors. A contextor is a software abstraction that models relationships between observables. Contextors share a common I/O structure including control channels and meta-data to ensure and express QoS (e.g., precision, stability), as well as common properties such as reflexivity and rema-nence. They can be combined as oriented graphs or encapsulated into higher computational units.

WComp middleware for ubiquitous computing: Aspects and composite event-based Web services

After a survey of the specific features of ubiquitous computing applications and corresponding middleware requirements, we list the various paradigms used in the main middlewares for ubiquitous computing in the literature. We underline the lack of works introducing the use of the concept of Aspects in middleware dedicated to ubiquitous computing, in spite of them being used for middleware improvement in other domains. Then, we introduce our WComp middleware model, which federates three main paradigms: event-based Web services, a lightweight component-based approach to design dynamic composite services, and an adaptation approach using the original concept called Aspect of Assembly. These paradigms lead to two ways to dynamically design ubiquitous computing applications. The first implements a classical component-based compositional approach to design higher-level composite Web Services and then allow to increment the graph of cooperating services for the applications. This approach is well suited to design the applications in a known, common, and usual context. The second way uses a compositional approach for adaptation using Aspect of Assembly, particularly well-suited to tune a set of composite services in reaction to a particular variation of the context or changing preferences of the users. Having detailed Aspect of Assembly concept, we finally comment on results indicating the expressiveness and the performance of such an approach, showing empirically that principles of aspects and program integration can be used to facilitate the design of adaptive applications.

SLCA, composite services for ubiquitous computing

Main concepts to handle in ambient computing applications are hard to integrate at the same time. After studying middlewares handling a part of the challenge, and after studying possiblities of main paradigms in name of CBSE and SOA, we present our Service Lightweight Component Architecture (SLCA) model, based on three main paradigms: Web services, enabling entities interoperability, dynamic discovery, and distribution, lightweight component assemblies to create composite Web services, allowing a high dynamicity, and events, giving applications reactivity and a maximal decoupling between entities, thus enabling an even higher dynamicity. This leads to conciliate both service oriented and event driven approaches in a new way to manage a graph of cooperating services in ubiquitous systems.

Service Composition Based on Natural Language Requests

The easiest way for a user to express his needs regarding a desired service is to use natural language. The main issues come from the fact that the natural language is incomplete and ambiguous, while the service composition process should lead to valid services. In this paper we propose a natural language service assemblage method based on composition templates (patterns). The use of templates assures that the composition result is always valid. The proposed system, called NLSC (Natural Language Service Composer), was implemented on the top of a service-oriented middleware called WComp and tested in an intelligent home environment.

WComp, a Middleware for Ubiquitous Computing

Ubiquitous computing relies on computers present everywhere, at any times and in any things. Indeed with recent years advance in mobile communication technologies and the miniaturization of computer hardware, processing units are becoming invisible and a part of the environment. Middlewares for ubiquitous computing have to manage three main features specific to their environment: devices’ mobility, devices’ heterogeneity and environment’s dynamicity. The devices’ mobility, due to motion of users and their associated devices, forbids to assume that entities are known and will always be available. The second concept, entity’s heterogeneity, outlines the diversity between devices’ capabilities and functionalities provided by new smart objects. Finally, the environment high dynamicity illustrates the ubiquitous world entropy with the appearance and disappearance of devices. Devices used to create applications are thus unknown before discovering them. Then, ubiquitous computing must deal with such a dynamic software environment (called software infrastructure afterwards). As a result, future ubiquitous computing architectures must take into account those three constraints to solve ubiquitous computing challenges. Our model of middlewareWComp is based on three parts: a software infrastructure, a service composition architecture, and a compositional adaptation mechanism. To manage the dynamicity and heterogeneity of entities in the software infrastructure, we highlight the use of Web Service Oriented Architecture for Device (WSOAD). This will be discussed in section 2. Ubiquitous applications are then based on a set of Web services for devices that must interact with each other. Consumers can not edit these services. Therefore, in order to add new functionalities to the system, an application has to be a composition of services for devices. Such an application, and thus such a composition, must be modifiable at runtime. The second part of the WComp middleware enables us to make such applications by dynamically composing services from the software infrastructure. To allow reusability of newly created functionalities, and for scalability purposes, such composition can be encapsulated as a composite service. This part of the system will be presented in Section 3. Moreover, the infrastructure of ubiquitous computing applications evolves dynamically led by appearances and disappearances of objects or devices. The variation of this infrastructure is dynamic due to arbitrary node mobility, failures or energy constraints. The service composition must be as relevant as possible according to the underlying software infrastructure. Managing these

Paper metaphor for tabletop interaction design

The aim of this paper is to explore new metaphors for interaction design on tabletop system. Tabletop systems are shared horizontal surface for co-located collaboration, which leads to original problems when designing interactions. We propose two metaphors based on the paper: the peeling metaphor, and the slot metaphor, and then suggest a way of using them to design new interactions for solving some of the problems of tabletop systems: documents organization, documents transmission and documents duplication.

Contextor: capture and dynamic distribution of contextual information

Without the support of adequate software infrastructures, the implementation of context sensitive interactive systems is hard to achieve in a sound way. In this article, we propose the notion of contextor, a software abstraction that supports the operational deployment of interaction contexts. We show how contextors are organized into levels of abstraction, and how these levels fit within the Arch architecture reference model for interactive systems. Based on the P2P paradigm, the contextor infrastructure is intended to support both mobility and ubiquity. Similar in spirit to the Context Toolkit, we make the differences explicit.

Adaptations interferences detection and resolution with graph-transformation approach

The adaptation of software applications is a critical need in ubiquitous computing. This adaptation should be done at runtime as a response to changes in software infrastructure. Each adaptation occurs correctly when it is separated but it may interact with other adaptations when they are composed. These interactions can affect the target behavior after adaptation. We call this interference. In this paper, we present an original approach to resolve interference. We represent applications and their adaptations by graphs; then we apply graph transformation rules on these graphs to resolve interferences.

Toward a Behavioral Decomposition for Context-Awareness and Continuity of Services

Many adaptative context-aware middleware exist and most of them rely on so-called vertical architectures that offer a functional decomposition for contextawareness. This architecture has a weak point: it does not allow the system handling both dynamics of the changing environment and applications. To avoid this, we propose an approach for context-awareness based on a behavioral decomposition, and because each behavior must complete all functionalities necessary for contextawareness, we introduce an hybrid decomposition. It consists in a functional decomposition into a behavioral decomposition. This approach derives benefits from both decomposition, first allowing to handle environment and application’s dynamics, second introducing reusability and modularity into behaviors.

Context adaptative systems based on horizontal architecture for ubiquitous computing

Many adaptative context-aware middleware exist and mostly rely on so-called vertical architectures that offer a functional decomposition for context-awareness. This architecture has a weak point: it leads to data centralization. Our mechanism for adaptation: the Aspects of Assemblies is based on a horizontal architecture. This type of architecture separate the system into behavior and is based on a decentralized approach. However, after having shown some limitations of AAs in the field of context-awareness we will introduce a way to improve them using a multi-cycle weaving approach. Then, using this approach we will be able to build context-adaptative systems that interact directly with their environment. Finally we will evaluate our approach in term of reactivity.