Software
The software systems I build are made publicly available as open
source. You can find downloadable code and more information at the
following web sites.
Logical Neighborhoods is a novel programming abstraction for WSNs that
redefines the traditional notion of physical neighborhood, implicitly
defined by node positions and communication ranges. Differently, a
logical neighborhood includes nearby nodes that satisfy predicates
over their static (e.g., type) or dynamic (e.g., sensed values)
characteristics. The span of the neighborhood and the definition of
its predicates are specified declaratively, along with requirements
about the cost of the communication involved. Logical neighborhoods
enable the programmer to slice the network according to the
application needs, effectively replacing the physical neighborhood
provided by wireless broadcast with a higher-level,
application-defined notion of proximity.
Most often, WSN programmers work at the level of the operating system,
using basic communication primitives. Differently, TeenyLIME empowers
programmers with a higher level of abstraction by replacing the
OS-level communication constructs with the notion of a shared memory
space spanning neighboring (1-hop) nodes. TeenyLIME can be used to
implement both application-level and system-level mechanisms, e.g.,
routing and MAC protocols. In addition, unlike most programming models
in the WSN literature, TeenyLIME is extensively used in real-world WSN
deployments,
e.g.,
monitoring of heritage buildings
and
adaptive
lighting in road tunnels, where it provides a foundation to build
efficient systems with reduced programming effort.
Developers are increasingly exploiting the Publish-Subscribe (P/S)
paradigm to implement sophisticated distributed applications. Although
the loosely coupled interactions fostered by P/S are an asset during
the design and implementation phases, developers struggle in verifying
the system behavior. To tackle this problem, we developed Loupe: a
domain-specific model checker. In Loupe, the P/S paradigm is embedded
within the checking engine, and the traditional P/S operations become
first-class citizens in the modeling language. This makes it easier to
model applications built on top of a P/S system. In addition, a
dedicated state abstraction mechanism enables modeling P/S
architectures at unprecedented levels of detail, without incurring in
severe state explosion problems.
© 2006-2012 Luca Mottola | Last updated: November 13rd, 2010 | Design by Andreas Viklund
