L IME: A Middleware for Physical and Logical Mobility Amy L. Murphy Dept. of Computer Science University of Rochester P.O. Box 270226 Rochester, NY, 14627, USA murphy@cs.rochester.edu Gian Pietro Picco Dip. di Elettronica e Informazione Politecnico di Milano P.za Leonardo da Vinci, 32 20133 Milano, Italy picco@elet.polimi.it Gruia-Catalin Roman Dept. of Computer Science Washington University One Brookings Drive St. Louis, MO 63130, USA roman@cs.wustl.edu Abstract LIME is a middleware supporting the development of ap- plications 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 con- text for computation, represented in Linda by a globally ac- cessible, persistent tuple space, is represented in LIME by transient sharing of the tuple spaces carried by each indi- vidual mobile unit. Linda tuple spaces are also extended with a notion of location and with the ability to react to a given state. The hypothesis underlying our work is that the resulting model provides a minimalist set of abstractions that enable rapid and dependable development of mobile applications. In this paper, we illustrate the model under- lying LIME, present its current design and implementation, and discuss initial lessons learned in developing applica- tions that involve physical mobility. 1. Introduction Middleware has emerged as a new development tool which can provide programmers with the bene£ts of a powerful virtual machine specialized and optimized for tasks common in a particular application setting without the major investments associated with the development of application-speci£c languages and systems. Given the com- plexities associated with software involving mobile hosts and agents, middleware is expected to establish itself as an important new technology. This paper addresses middle- ware for mobility and presents an example of how a new abstract model supporting both physical and logical mobil- ity can be delivered in the form of middleware. The starting point for our investigation was the notion that a coordination perspective on mobility holds the key to simplifying the development effort. The idea is to elimi- nate the programmer’s need to be concerned with the me- chanics of communication among hosts and agents. The interactions among mobile units of any kind are expressed separately from the application processing and are imple- mented in a transparent manner by the middleware fabric. The middleware presented in this paper (LIME—Linda in a Mobile Environment) explores this idea by providing pro- grammers with a global virtual data structure, a Linda-like tuple space whose content is determined by the connectivity among mobile hosts. Individual programs perceive the ef- fects of mobility as behind-the-scene changes in the content of their own local tuple spaces. The resulting middleware is essentially an embodiment of a model of mobility in which coordination takes place via a global tuple space physically distributed among mobile units and logically partitioned ac- cording to connectivity among the units. When viewed in the broader context of mobility, LIME is indeed a new breed of middleware. LIME is general pur- pose, model-centric, and inclusive of both physical and log- ical mobility. It provides novel programming constructs in a manner that is sensitive to the constraints imposed by the realities of mobility. In the remainder of the paper we provide an overview of LIME (Section 2), we examine the implementation strategy (Section 3), and review our experience with several appli- cations developed using LIME (Section 4). The paper con- cludes with a brief discussion of lessons learned (Section 5) followed by conclusions (Section 6) and references. 2. LIME: Linda in a Mobile Environment The LIME model [7] aims at identifying a coordination layer that can be exploited successfully for designing appli- cations that exhibit logical and/or physical mobility. LIME borrows and adapts the communication model made popu- lar by Linda [2]. In Linda, processes communicate through a shared tuple space that acts as a repository of elementary data structures,