Abstract. Coordinating the interactions of applications running on the diversity of devices that will be common in ubiquitous computing environments is still a difficult and not completely solved problem. We look at one such environment, an interactive workspace, where groups come together to collaborate on solving problems. Such a space will contain a heterogeneous collection of both new and legacy applications and devices. We propose that a tuplespace model with several extensions is ideal for coordination in this environment. We present a prototype implementation of such a model called the Event Heap. Finally, we show that the system has performed well in actual use over the last year and a half in our prototype interactive workspace, the iRoom. 1

Abstract. An increasing number of distributed applications will be written for mobile hosts, such as laptop computers, third generation mobile phones, personal digital assistants, watches and the like. Application engineers have to deal with a new set of problems caused by mobility, such as low bandwidth, context changes or loss of connectivity. During disconnection, users will typically update local replicas of shared data independently from each other. The resulting inconsistent replicas need to be reconciled upon re-connection. To support building mobile applications that use both replication and reconciliation over ad-hoc networks, we have designed xmiddle, a mobile computing middleware. In this paper we describe xmiddle and show how it uses reflection capabilities to allow application engineers to influence replication and reconciliation techniques. xmiddle enables the transparent sharing of XML documents across heterogeneous mobile hosts, allowing on-line and off-line access to data. We describe xmiddle using a collaborative e-shopping case study on mobile clients.

Current trends in computing include increases in both distribution and wireless connectivity, leading to highly dynamic, complex environments on top of which applications must be built. The task of designing and ensuring the correctness of applications in these environments is similarly becoming more complex. The unified goal of much of the research in distributed wireless systems is to provide higher-level abstractions of complex low-level concepts to application programmers, easing the design and implementation of applications. A new and growing class of applications for wireless sensor networks require similar complexity encapsulation. However, sensor networks have some unique characteristics, including dynamic availability of data sources and application quality of service requirements, that are not common to other types of applications. These unique features, combined with the inherent distribution of sensors, and limited energy and bandwidth resources, dictate the need for network functionality and the individual sensors to be controlled to best serve the application requirements. In this article, we describe different types of sensor network applications and discuss existing techniques for managing these types of networks. We also overview a variety of related middleware and argue that no existing approach provides all the management tools required by sensor network applications. To meet this need, we have developed a new middleware called MiLAN. MiLAN allows applications to specify a policy for managing the network and sensors, but the actual implementation of this policy is effected within MiLAN. We describe MiLAN and show its effectiveness through the design of a sensor-based personal health monitor.

Event-based systems are developed and used to integrate components in loosely coupled systems. Research and product development focused so far on e#ciency issues but neglected methodological support to build such systems. In this article, the modular design and implementation of an event system is presented which supports scopes and event mappings, two new and powerful structuring methods that facilitate engineering and coordination of components in event-based systems. We give a

and have found that it is complete and satisfactory in all respects, and that any and all revisions required by the final examining committee have been made.

In this paper, we argue that middleware for wired distributed systems cannot be used in a mobile setting, as the principle of transparency that has driven their design runs counter to the new degrees of awareness imposed by mobility. We propose the marriage of reflection and metadata as a means for middleware to give applications dynamic access to information about their execution context. Finally, we describe a conceptual model that provides the basis of our reflective middleware.

Event notification services enable loose coupling and they are therefore becoming an essential part of distributed systems' design. However, the development of event services follows the early stages of programming language evolution, disregarding the need for efficient mechanisms to structure event-based applications. In this paper, the well-known notion of scopes is introduced to event-based systems. We show that limiting the visibility of events is a simple yet powerful mechanism that allows to identify application structure and offers a module construct for the loosely coupled components in event-based systems. We are able to customize the semantics of scoped event notification services by binding meta-objects to the application structure that reify important aspects of notification delivery, like interface mappings and transmission policies. The scoping concept facilitates design and implementation by offering encapsulation and adaption of syntax and semantics of eventbased systems.

In the rapidly developing field of sensor networks, bridging the gap between the applications and the hardware presents a major challenge. Although middleware is one solution, it must be specialized to the qualities of sensor networks, especially energy consumption. The work presented here provides two contributions: a new operational setting for sensor networks and a middleware for easing software development in this setting. The operational setting we target removes the usual assumption of a central collection point for sensor data. Instead the sensors are sparsely distributed in an environment, not necessarily able to communicate among themselves, and a set of clients move through space accessing the data of sensors nearby, yielding a system which naturally provides context relevant information to client applications. We further assume the clients are wirelessly networked and share locally accessed data. This scenario is relevant, for example, when relief workers access the information in their zone and share this information with other workers. Our second contribution, the middleware itself, is an extension of LIME, our earlier work on middleware for mobile ad hoc networks. The model makes sensor data available through a tuple space interface, providing the illusion of shared memory between applications and sensors. This paper presents both the model and the implementation of our middleware incorporated with the Crossbow Mote sensor platform.

Lime (Linda in a Mobile Environment) is a model and middleware supporting the development of applications that exhibit physical mobility of hosts, logical mobility of agents, or both. Lime adopts a coordination perspective inspired by work on the Linda model. The context for computation, represented in Linda by a globally accessible, persistent tuple space, is refined in Lime to transient sharing of identically-named tuple spaces carried by individual mobile units. Tuple spaces are also extended with a notion of location and programs are given the ability to react to specified states. The resulting model provides a minimalist set of abstractions that facilitate rapid and dependable development of mobile applications. In this paper, we illustrate the model underlying Lime, provide a formal semantic characterization for the operations it makes available to the application developer, present its current design and implementation, and discuss lessons learned in developing applications that involve physical mobility.

Abstract. This paper presents Limone, a new coordination model that facilitates rapid application development over ad hoc networks consisting of logically mobile agents and physically mobile hosts. Limone assumes an agent-centric perspective on coordination by allowing each agent to define its own acquaintance policy and by limiting all agent-initiated interactions to agents that satisfy the policy. Agents that satisfy this acquaintance policy are stored in an acquaintance list, which is automatically maintained by the system. This asymmetric style of coordination allows each agent to focus only on relevant peers. Coordination activities are restricted solely to tuple spaces owned by agents in the acquaintance list. Limone tailors Linda-like primitives for mobile environments by eliminating remote blocking and complex group operations. It also provides timeouts for all distributed operations and reactions, which enable asynchronous communication with agents in the acquaintance list. Finally, Limone minimizes the granularity of atomic operations and the set of assumptions about the environment. In this paper we introduce Limone, explain its key features, and explore its capabilities as a coordination model. A universal remote control implementation using Limone provides a concrete illustration of the model and the applications it can support. 1