Section: New Results
Software Engineering for Ambient Intelligence
COSMOS ( COntext entitieS coMpositiOn and Sharing )  ,  is a component-based framework for context information management. This framework targets ubiquitous, context-aware applications. It deals with the gathering, the processing and the interpretation of context data. This is a middle layer between the infrastructure and the applications. The idea is that context-aware applications have to deal with numerous information coming from the hardware (CPU, memory, network, etc.) and the service resources available in their environment. COSMOS enables to structure this information and to represent adaptation policies as graphs of components. Each node in the graph represents a basic action of collecting or processing of a context information. We have defined a library of components for representing such nodes and a library of architectural patterns for connecting these nodes. By this way, we are able to more easily design and reuse adaptation policies for context-aware applications. COSMOS can be downloaded from http://picoforge.int-evry.fr/projects/svn/cosmos .
Annotations, in the Java programming language, are a way to embed meta-data into the source-code of a program. Annotations can be used to extend the Java language with concepts specific to a domain. When used in this manner, annotations serve as means to reduce the semantic gap between concepts in the problem domain and the concepts provided by the programming language. For the annotation framework user— i.e. , the application programmer—it is important to understand how different annotations relate to each other in order to correctly use them and to get errors as soon as possible when these annotations are not correctly used.
Annotation frameworks have already been adopted by industry; however, their development remains complex, and it is done largely in an ad-hoc manner. When developing the annotation framework, the programmer must make sure that the program that uses the annotation complies with the constraints defined for it. Such constraints are often relegated to the documentation of the framework, since current annotation processors do not provide a way to specify and check them. In addition to this, current annotation processors just offer to the framework programmer the AST of the program as manipulation entity. This forces the programmer to reify the annotations by himself if he wants higher abstraction elements.
To help the annotation framework developer, we have proposed two annotation frameworks  . The first one, called AVal, provides a number of reusable, declarative and extensible constraints that can be used to specify the annotation framework, and can be interpreted in order to validate an annotated program. The second one, called ModelAn, allows the annotation framework developer to describe a model that corresponds to the annotations in the framework, and to express the constraints in terms of this model  . Annotated programs are then represented as instances of the (annotation) model, and the constraints checked on it. From this model, Java classes that reify the annotations are generated. The reified annotations can serve as starting point for the interpretation of the annotated program.
To validate the approach, we construct the annotation model, and describe the constraints as AVal and OCL expressions of three industrial annotation frameworks: Fraclet, an annotation framework for the Fractal component model, JWS for the development of Web Services in Java, and the Java Persistence API, part of the EJB3 specification. This work is the result of Carlos Francisco Noguera Garcia's PhD thesis.
Modelling has always been an essential part of software development. Models represent the domain of the software or make abstractions from the implementation. A recent trend in software development is Model-Driven Engineering, where models play a pivotal role in that programs or other models are generated from them. As such, it seems that concepts, behaviour and rules of Ambient Computing, and Context-Aware Computing in particular, have to be expressed at the modelling level. Evidently, the models have to be active and intimately connected to the actual implementation at the computational level, rather than serving passive documentation purposes.
In an ubiquitous computing setting it is however more natural to assume that each device in the environment manages its own part of the context. Distributing such context implies that support is needed for connection volatility. Using Tagged Futures and Spoon Graffiti we have implemented such support, allowing context to be distributed without adding a significant overhead to development. Preliminary results can be found in  . We have also defined the challenges of building context aware applications  , and a possible approach has been described. Several prototypes have also been built in order to validate the ideas presented in these research proposal papers. These prototypes are intended to run in mobile devices and initially use web services to interact with the environment. Two different platforms are used to evaluate the common and particular features of mobile applications. This experimentation simplifies the design of models and the setup of a Software Product Line that automatically generates parts of these applications. The perspectives of this work involve the combination of SCA and MDE, to achieve static and dynamic adaptation.
Adaptive Middleware for Context-Awareness
In pervasive environments, several entities exist that provide information and services that can be useful for the users  . However, the providers of these information and services are heterogeneous considering aspects, such as communication and discovery. Hence, in order to deal with this heterogeneity we want to build an adaptable middleware platform that will be deployed on mobile devices. This middleware platform will enable those devices to access the different resources present in the environments. In order to do that, we started exploring the existent context-aware middleware. This allowed the identification of challenges that are necessary to tackle in ubiquitous computation, such as context retrieval, dynamic and static adaptation, mobility and service discovery. We also identified Fractal  , Service Component Architecure (SCA)  , and COSMOS  ,  (a component-based framework for managing context in pervasive environments) as tools that can help in this work. Furthermore, we have defined a first architecture of the middleware platform  . In the next year, we expect to work in the detail specification and implementation of this middleware platform in the context of the CAPPUCINO project (cf. section 8.1 ).