A State-Based Programming Model for Wireless Sensor Networks

Abstract
Sensor nodes are small, inexpensive, and programmable devices that combine
an autonomous power supply with computing, sensing, and wireless communication
capabilities. Networks of sensor nodes can be deployed in the environment
at a large scale to unobtrusively monitor phenomena of the real world.
Wireless sensor networks are an emerging field of research with many potential
applications. So far, however, only few applications have actually been realized.
This is in part due to the lack of appropriate programming support, which
makes the development of sensor-network applications tedious and error prone.
This dissertation contributes a novel programming model and development environment
for the efficient, modular, and well structured programming of wireless
sensor nodes.
Today there are two principal programming models used for sensor nodes,
the multi-threaded model and the event-driven model. The multi-threaded model
requires system support that is often considered too heavy for sensor nodes that
operate at the low end of the resource spectrum. To cope with this issue, the
event-driven model has been proposed. It requires very little runtime support
by the system software and can thus be implemented even on the most constrained
sensor nodes.
The simple and lightweight approach to system software, however, tends to
make event-driven applications in turn quite memory inefficient: Since the eventdriven
model limits the use of local variables, programmers need to store temporary
data in global variables. The memory of global variables, however, cannot
easily and automatically be reused, hence the memory inefficiency. To counter
this effect, programmers can resort to manual memory management, though
this significantly affects program correctness and code modularity. In addition
to its drawback of memory inefficiency, event-driven programming requires developers
to manually keep track of the current program-state, which makes code
modularization and debugging difficult, and leads to unstructured code.
The key contribution of this dissertation is to show that the inadequacies of
the event-driven model can be remedied without impairing its positive aspects,
particularly its memory-efficient realization in sensor-node system software.
Concretely, we present the Object State Model (OSM), a programming model
that extends the event-driven programming paradigm with a notion of hierarchical
and concurrent program states. Our thesis is that such a state-based model
allows to specify well-structured, modular, and memory-efficient programs, yet requires
as few runtime-resources as the event-driven model. To support this claim, we also
present a programming environment based on the OSM model (including a programming
language and compiler), as well as a sensor-node operating system
capable of executing OSM programs.