Programming the Ubiquitous Network: A Top-Down Approach Urs Bischoff, Gerd Kortuem Lancaster University, Lancaster LA1 4YW, UK Abstract. A ubiquitous network is characterised by a large number of small computers embedded in our environment. Writing distributed applications for this kind of network can be a challenging task. Pro- gramming and re-programming each single device is not feasible; it is too time consuming, too costly and too error prone. We argue that a top-down approach to writing applications is useful. We propose a high- level language that can specify a ubiquitous network’s global behaviour. A compiler can automatically generate device-level executables from this global specification. 1 Introduction Writing and deploying software applications can be a challenging task. Especially when dealing with the ubiquitous computing vision of an “invisible” infrastruc- ture embedded in our environment we face challenges we have not encountered in traditional networks. We are working on the idea of embedding computers and sensors into real physical objects. By giving them processing and sensing capa- bilities we can make these objects “smart”. Our vision is a world of these objects and other more powerful devices (e.g. PDAs) to form a smart environment. We refer to such an environment as a ubiquitous network. From a system’s perspective we face one main problem, which is inherent to this new kind of network: how can we effectively implement an application for such a large number of ubiquitous devices? This new network allows us to realise new kinds of applications. What we need are suitable methods for designing, implementing and deploying applications. With this large number of devices it is not possible to program and re- program each device individually. This would be too time consuming, too costly and too error prone. This is even more relevant if we consider a dynamic envi- ronment with changing device configurations and often changing requirements. We argue that instead of focusing on each individual device independently we need to focus on programming the entire network as a whole. Knowing the individual device that executes the application is of less interest. We need to find ways to define applications independently of the underlying distributed comput- ing environment and a way to inject them dynamically into the network. We propose a solution that addresses the network as a whole. Rather than performing sensing and interpretation bottom-up, i.e. driven by available sen- sor data, we envision a top-down approach. This top-down approach is based