A State-Based Programming Model for Wireless Sensor Networks

3 Programming and Runtime
Environments
Developing a sensor network application typically requires to program individual
sensor nodes. Today, programming of individual sensor nodes is mostly
performed by programmers directly. Even though research has made much
progress in distributed middleware and high-level configuration languages for
sensor nodes, typically most of the application code still has to be specified by
the hand of a programmer.
To support application programming, several programming frameworks exist
for sensor nodes. Programming frameworks provide a standard structure
to develop application programs, typically for a specific application domain,
for example, Graphical User Interface programming, or, in our case, sensornode
programming. Programming frameworks for sensor nodes consist of a
runtime environment with reusable code and software components, programming
languages, and software tools to create and debug executable programs
(see Fig. 3.1). The conceptual foundation of a programming framework is a programming
model. The programming model defines the conceptual elements in
which programmers think and structure their programs. These elements are
operating-system abstractions (such as threads, processes, dynamic memory,
etc.) and language abstractions (such as functions, variables, arguments and
return parameters of procedural programming languages). Other elements are
abstractions for frequently used (data) objects (such as files, network connections,
tracking targets, etc.), as well as convenient operations and algorithms on
those objects.
Programs specified based on high-level programming models, however, do
not directly execute on the sensor-nodes hardware. Rather, they require a software
layer to provide them with a runtime environment. That runtime environment
bridges the gap between the high-level programming model and the lowlevel
execution model of the processor. It typically consists of middleware components,
code libraries, OS system calls, and compiler-generated code, which
together provide the implementations of the model’s abstractions. Naturally, a
programming model with more and more expressive abstractions will require
more support from the runtime environment.
The explicit goal of traditional computing systems is to accommodate a wide variety
of applications from different domains. Therefore, they typically provide a
“thick” and powerful system software that supports rich programming models
and many abstractions. From this variety, application designers can (and must)
choose a model that suits their applications needs best. Sensor-node platforms,
however, are often subjected to severe resource constraints. Therefore they can
afford only a thin system software layer and can thus offer only a limited programming
model. The designers of programming frameworks for sensor-node