User Tools

Site Tools


Sidebar

Jump to
AmbientTalk
CRIME
iScheme

research:doforreal

This is an old revision of the document!


Distributed Objects for Real

Over the past year, a number of researchers at the Software Languages Lab have been involved in experiments designed to uncover new programming abstractions to facilitate the development of mobile RFID-enabled applications.

During these experiments, we have approached the development of such applications from two opposing perspectives, which are briefly described below.

Volatile Data Clouds

The volatile data clouds model can be considered a special case of Reactive Context-Aware Programming specifically applied to the domain of mobile RFID-enabled applications.

The volatile data clouds model considers RFID tags to be data containers whose presence or absence can be used to steer the application. Therefore, it focusses on designing a general means to represent the collection of currently visible tags.

Since the collection is implicitly tied to the environment and changes frequently in response to events emitted by the RFID reader, change is at the very heart of the model. To permit application developers to respond to and propagate these changes without having to explicitly register a plethora of observers, we borrow concepts from reactive programming.

Concretely, the collection of visible tags is modeled as a reactive collection. In order to test for the presence of a particular tag, one can invoke the contains method of the reactive collection, which results in a new dependent reactive value. That value is transparently updated whenever the collection changes. This automatic propagation of changes to a reactive collection of RFID tags is a determining factor in the expressiveness of applications that use the volatile data cloud metaphor.

Another important aspect is efficiently detecting when interesting patterns occur in a reactive tag collection. A pattern of interest can be the presence of a particular (kind of) tag, but should extend to combinations of interesting tags. To detect such occurrences, we make use of pattern matching rules which can be applied to any reactive collection. This technique allows building RFID applications using a declarative programming style.

Tags Objects

The tag objects model represents RFID tags as full-blown objects, which introduces a natural mechanism to deal with mutable tag data. More information as well as videos of our experiments can be found here.

While the volatile data clouds model considers RFID tags to be containers of data which is to be filtered and interpreted by the application, the tag objects model conceived them as hosts for full-fledged objects.

Applications can interact with these objects and e.g. invoke methods on them. In this case, the tag contains a marshalled object representation which is implicitly unmarshalled to provide a live object which applications can interact with.

When treating tags as objects, it is important to deal with the ephemeral nature of the connection between the mobile application and any particular tag. A first problem to be tackled is how applications detect new tags as they come into range. This is addressed by the introduction of a semantic service discovery mechanism, which allows applications to be notified when an interesting tag appears. The use of a service discovery mechanism also provides an implicit mechanism to disregard tags which contain objects that are irrelevant to the application. For instance, an application can choose to only discover objects of type Book or Ingredient.

Once a tag object has been discovered, the application can start to interact with it. However, if either the user of the application or the tagged object is roaming, it is extremely likely that the tag will (temporarily) go out of range. The tagged object model requires that the programming abstraction are sufficiently robust to deal with such sudden disappearances. Therefore, tag objects should be treated as “remote objects”; objects which can only be addressed using asynchronous messages. Hence, when a tag goes out of range, all messages that are sent to it are buffered. Subsequently, when the tag comes in range again, all buffered messages sent to it can be flushed.

While messages are implicitly buffered during a temporary disconnection, it is important to provide the application programmer with the necessary abstractions to explicitly detect when a tag has disappeared or when it has been unreachable for a certain period of time. Therefore, the programming model should allow the application to explicitly provide disconnection and reconnection listeners.

Within the tag object model, we have conducted initial experiments on how to use ad hoc replication strategies which could allow continued use of a tag object even when the tag is temporarily unreachable. When the tag becomes reachable again, updates can be synchronized. With such a custom replication strategy in place, it can in principle be possible to treat tag objects as “local objects”; objects which can be addressed with both asynchronous and synchronous messages.

Comparison

Having implemented both models, it remains unclear whether one of the models presented in this paper is to be preferred over the other. As it stands, both models have shown to cater to different kinds of applications. Moreover, when analysing the strengths and weaknesses of each of the models, they have shown to be largely complementary.

The volatile data clouds model treats RFID tags as simple containers of data and aims at providing applications with expressive means to represent a collection of nearby tags which is constantly in flux. Consequently, the model focusses on being able to expressively filter such collections and detect the presence of (a combination of) tags, to which the application can respond. Using volatile data clouds as a means to represent nearby tags allows the programmer to abstract over the events that underly the discovery of new tags and the handling of their disappearance. The cost incurred by using these abstractions is the need for a rather heavy-weight infrastructure to properly handle reactive computation. Furthermore, this model considers RFID tags almost exclusively as a means to indicate the presence of a physical object in close proximity to the device that is running a particular application.

The tag objects model on the other hand treats the contents of an RFID tag as a full-fledged object. This makes the model capable of interacting naturally with tags that contain marshalled objects and makes it particularly interesting to model interactions with active tags. Active tags are RFID tags which contain their own power source and are capable of independently performing (some limited form of) computation. Another advantage is that the model only requires a service discovery mechanism and a means to buffer messages, which makes it considerably more light-weight that the volatile data clouds model. The downside of this method that it provides only crude support to detect the presence of (combinations of) tags in the environment. Furthermore, the application needs to explicitly provide listeners to react to the events signalling the disconnection or reconnection of a tag.

In all likelihood, a programming model that fully leverages the advantages of a world teeming with tagged objects will incorporate elements of both models presented here.

Further Reading

* Distributed Objects for Real. Stijn Mostinckx, Andoni Lombide Carreton, Kevin Pinte, Wolfgang De Meuter. Technical report, 2010, Vrije Universiteit Brussel pdf

research/doforreal.1280922937.txt.gz · Last modified: 2010/08/04 14:25 (external edit)