Because of the proliferation of mobile computing devices, research fields such as ubiquitous and pervasive computing are slowly becoming reality. These research areas envision distributed applications that are smoothly integrated in our environment and unobtrusively help us perform every day tasks. For example: a smart fridge that tells the user (by communicating with an application on his personal computing device such as his smartphone) which dishes can be prepared with the ingredients present in the fridge, and makes suggestions to the user for which ingredients to buy to complete certain dishes.

For such a scenario to become reality, these new breed of applications have to be able to acquire information about objects in the physical environment (e.g. the ingredients in the smart fridge of the scenario described above) and associate information with these physical objects (“things”) themselves. This is currently achieved by means of RFID (Radio Frequency IDentification) technology, which allows tagging physical “things” with tiny and very cheap chips that are able to store a limited amount of information. The emerging network of classic computing devices and “things” is called the Internet of Things.

RFID tags have some severe hardware limitations that have to be taken into account when interacting with them from within an application: wireless communication via radio waves is very prone to errors and large numbers of tags can become unreachable or reappear at any point in time. Current approaches require either the programmer to deal with the hardware characteristics of RFID technology manually, or use a high-level framework or middleware targeted at specific application domains that make use of RFID tags (e.g. stock management). The first approach makes programming RFID applications very tedious and results in application code polluted with error handling. The second approach only focuses on certain types of applications, while we envision general pervasive computing scenarios. Furthermore, both applications do not interact with things in the environment in an object-oriented fashion, which means that modern software engineering techniques are not directly applicable.

At the PROG lab we have as a research artifact the experimental programming language AmbientTalk, which is a domain-specific language that targets pervasive applications running in mobile wireless networks (e.g. smartphones connected via wireless peer-to-peer connections). We have successfully mapped the AmbientTalk communication model that deals with unreliable wireless connections to RFID technology. However, the communication with the tags is only one part of the story. As mentioned in the previous section, we want to interact with things in the environment (represented by RFID tags) in an object-oriented fashion, i.e. we want to send messages to these objects and design the appropriate interfaces to their encapsulated data, to in the end be able to blur the distinction with physical objects (“things”) and their digital counterparts.

There are many possible ways to achieve the above, and some may be more appropriate to a specific situation than others. One could, for instance, use direct remote communication with an RFID tag in situations where the connection with a tag is reasonably stable. On the other hand, when the connection with the tag is very intermittent, with such an approach the application may become unresponsive. One might opt to replicate the object represented by the RFID tag locally such that availability of that specific object is guaranteed for the application. But, when different mobile applications have their own local replicas of such objects and mutate their encapsulated state, this requires a synchronization mechanism to guarantee data consistency when performing the changes on the physical data stored on the RFID tags.

The first goal of the thesis is to investigate different approaches of storing objects onto RFID tags (serialization might be a good starting point) and implement such a (most likely adapted) mechanism for the AmbientTalk language. The second goal of the thesis is to identify different communication models for the interaction with things and to try to implement one or more useful ones (e.g. locally replicated objects with a distributed synchronization algorithm). All the experiments and implementation can (and should) be done on real RFID hardware available at the lab. The AmbientTalk language is an ideal platform for these experiments, as it can interoperate with the underlying Java virtual machine and is highly extensible by means of reflection and metaprogramming techniques.