The literature on programming sensor networks has, by and large, focused on providing higher-level abstractions for expressing local node behavior. Kairos is a natural next step in sensor network programming in that it allows the programmer to express, in a centralized fashion, the desired global behavior of a distributed computation on the entire sensor network. Kairos’ compile-time and runtime subsystems expose a small set of programming primitives, while hiding from the programmer the details of distributed code generation and instantiation, remote data access and management, and inter-node program flow coordination. Kairos ’ runtime is greatly simplified by assuming eventual consistency in node state; this assumption underlies many practical distributed computations proposed for sensor networks. In this paper, we describe Kairos ’ programming model, and the flexibility and robustness it affords programmers. We demonstrate its suitability, through actual implementation, for a variety of distributed programs—both infrastructure services and signal processing tasks—typically encountered in sensor network literature: routing tree construction, localization, and object tracking. Our experimental results suggest that Kairos does not adversely affect the performance or accuracy of distributed programs, while our implementation experiences suggest that it greatly raises the level of abstraction presented to the programmer.

Sensor networks are notoriously difficult to program, given that they encompass the complexities of both distributed and embedded systems. To address this problem, we present the design and implementation of a declarative sensor network platform, DSN: a declarative language, compiler and runtime suitable for programming a broad range of sensornet applications. We demonstrate that our approach is a natural fit for sensor networks by specifying several very different classes of traditional sensor network protocols, services and applications entirely declaratively – these include tree and geographic routing, link estimation, data collection, event tracking, version coherency, and localization. To our knowledge, this is the first time these disparate sensornet tasks have been addressed by a single high-level programming environment. Moreover, the declarative approach accommodates the desire for architectural flexibility and simple management of limited resources. Our results suggest that the declarative approach is well-suited to sensor networks, and that it can produce concise and flexible code by focusing on what the code is doing, and not on how it is doing it.

A main challenge with developing applications for wireless embedded systems is the lack of visibility and control during execution of an application. In this paper, we present a tool suite called Marionette that provides the ability to call functions and to read or write variables on pre-compiled, embedded programs at run-time, without requiring the programmer to add any special code to the application. This rich interface facilitates interactive development and debugging at minimal cost to the node.

Abstract — There is widespread agreement that a higher level programming model for sensor networks is needed. A variety of models have been developed, but the community is far from consensus. We propose an intermediate language to speed up the exploration of this design space. Our language, called the Token Machine Language (TML) can be targeted by compilers for higher level systems. TML provides a layer of abstraction for a lower-level runtime environment, such as TinyOS. TML is intended to capture coordinated activity in a sensor network. Notable features of TML are its atomic action model of concurrency, and its unification of communication, control, and storage around the concept of a token. Tokens are small objects, typically under a hundred bytes, and can be disseminated across the network. A token causes computation upon its arrival at a site by invoking a token handler. The effect of the computation is to atomically change the token’s own state as well as the state of shared variables at the site. I.

The Abstract Task Graph (ATaG) is a data driven programming model for end-to-end application development on networked sensor systems. An ATaG program is a system-level, architecture-independent specification of the application functionality. The application is modeled as a set of abstract tasks that represent types of information processing functions in the system, and a set of abstract data items that represent types of information exchanged between abstract tasks. Input and output relationships between abstract tasks and data items are explicitly indicated as channels. Each abstract task is associated with user-provided code that implements the actual information processing functions in the system. Appropriate numbers and types of tasks can then be instantiated at compile-time or run-time to match the actual hardware and network configuration, with each node incorporating the user-provided code, automatically generated glue code, and a runtime engine that manages all coordination and communication in the network. This paper primarily deals with the key concepts of ATaG and the program syntax and semantics. The end-to-end application development methodology is discussed briefly. 1

It is currently difficult to build practical and reliable programming systems out of distributed and resource-constrained sensor devices. The state of the art in today’s sensornet programming is centered around a component-based language called nesC. nesC is a nodelevel language—a program is written for an individual node in the network—and nesC programs use the services of an operating system called TinyOS. We are pursuing an approach to programming sensor networks that significantly raises the level of abstraction over this practice. The critical change is one of perspective: rather than writing programs from the point of view of an individual node, programmers implement a central program that conceptually has access to the entire network. This approach pushes to the compiler the task of producing node-level programs that implement the desired behavior. We present the Pleiades programming language, its compiler,

Over the last several years, large-scale wireless mote networks have made possible the exploration of a new class of highly-concurrent and highly-distributed applications. As the horizon of what kinds of applications can be built on these networked embedded systems keeps expanding, there is a need to keep the activity of programming such systems easy, efficient, and scalable. We make three major contributions in this paper. First, we present a library for TinyOS and nesC that enables true multi-threading on a mote. This library includes support for all mote platforms in use currently (AVR, MSP). Second, we present a tool that can effectively and accurately compute stack requirements for multithreaded programs. Such analysis ensures that the stacks allocated to individual threads are correctly sized. Finally, we present a collection of programming abstractions that simplifies the construction of concurrent systems for the mote platform. We also present experimental results obtained from several example systems built using our concurrent programming abstractions and the underlying thread library. Categories and Subject Descriptors C.3 [Special purpose and Application-based systems]: Real-time and embedded systems; D.1.3 [Concurrent Programming]: Parallel programming; D.3.3 [Language Constructs and Features]: Concurrent programming structures

In this paper, we present Flask, a new programming language for sensor networks that is focused on providing an easy-to-use dataflow programming model. In Flask, programmers build applications by composing chains of operators into a dataflow graph that may reside on individual nodes or span multiple nodes in the network. To compose dataflow graphs across sensor nodes, Flask supports a lean, general-purpose communication abstraction, called Flows, that provides publish/subscribe semantics over efficient routing trees. At the heart of Flask is a programmatic wiring language, based on the functional language OCaml [13]. Flask’s wiring language allows dataflow graphs to be synthesized programmatically. The Flask wiring program is interpreted at compile time to generate a sensor node program in NesC, which is then compiled to a binary. Our design of Flask makes three main contributions. First, Flask allows the programmer to specify distributed dataflow applications in a high-level language while retaining the efficiency of compiled binaries and full access to TinyOS components. Second, Flask provides a unified framework for distributing dataflow applications across the network, allowing programmers to focus on application logic rather than details of routing code. Finally, Flask’s programmatic wiring language enables rich composition of dataflow operators, making it possible to develop higher-level programming models or languages directly in Flask. In this paper, we describe the design and implementation of the Flask language, its runtime system, the Flows communication interface, and a compiler that produces NesC code. We evaluate Flask through two motivating applications: a distributed detector of seismic activity (e.g., for studying earthquakes), and an implementation of the TinyDB query language built using Flask, showing that using Flask considerably reduces code complexity and memory size while achieving high runtime efficiency.

Sensor networks have a significant potential in diverse applications some of which are already beginning to be deployed in areas such as environmental monitoring. As the application logic becomes more complex, programming difficulties are becoming a barrier to adoption of these networks. The difficulty in programming sensor networks is not only due to their inherently distributed nature but also the need for mechanisms to address their harsh operating conditions such as unreliable communications, faulty nodes and extremely constrained resources. Researchers have proposed different programming models to overcome these difficulties with the ultimate goal of making programming easy while making full use of available resources. In this paper, we first explore the requirements for programming models for sensor networks. Then we present a taxonomy of the programming models, classified according to the level of abstractions they provide. We present an evaluation of various programming models for their responsiveness to the requirements. Our results point to promising efforts in the area and a discussion of the future directions of research in this area.

Wireless sensor networks (WSNs) are attracting great interest in a number of application domains concerned with monitoring and control of physical phenomena, as they enable dense and untethered deployments at low cost and with unprecedented flexibility. However, application development is still one of the main hurdles to a wide adoption of WSN technology. In current real-world WSN deployments, programming is typically carried out very close to the operating system, therefore requiring the programmer to focus on low-level system issues. This not only shifts the focus of the programmer away from the application logic, but also requires a technical background that is rarely found among application domain experts. The need for appropriate high-level programming abstractions, capable to simplify the programming chore without sacrificing efficiency, has been long recognized and several solutions have been hitherto proposed, which differ along many dimensions. In this paper, we survey the state-of-the-art in programming approaches for WSNs. We begin by presenting a taxonomy of WSN applications, to identify the fundamental requirements programming platforms must deal with. Then, we introduce a taxonomy of WSN programming approaches that captures the fundamental differences among existing solutions, and constitutes the core contribution of this paper. Our presentation style relies on concrete examples and code snippets taken from programming platforms representative of the taxonomy dimensions being discussed. We use the taxonomy to provide an exhaustive classification of existing approaches. Moreover, we also map existing approaches back to the application requirements, therefore providing not only a complete view of the state-of-the-art, but also useful insights for selecting the programming abstraction most appropriate to the application at hand.