Master's Dissertation - Managing the Object Soup in Ambient-Oriented Applications

• Explaining a thesis without becoming too technical is never easy. Therefore, let me first briefly sketch some of the context of my research. Current day, mobile devices are characterized by their ability to support advanced networking technologies like Bluetooth, Wi-Fi and more recently Near Field Communication (NFC). Such networking technologies enable mobile devices to spontaneously interact with each other in an ad-hoc manner. The spontaneous nature of this kind of interactions is significantly different from traditional client-sever interactions in two ways: first, there is no shared infrastructure to administer the connections and interactions. Second, devices communicate wirelessly over unreliable, volatile connections. These characteristics make it notoriously difficult to develop mobile (ambient) applications, especially applications that exploit these networking technologies at fullest.

  Generally, when developing mobile applications, objects across the network interact with each other over remote references. The problem is that intrinsically all these objects are all of the same kind, which means that when we obtain a remote reference to such object, we can access the object’s interface unrestrictedly. This makes that when the programmer wants to enforce restrictions on the way an object can be accessed and mutated across the network, he has to take care of this by hand. This is complex, especially in the case when the object's functionality evolves over time. On top of this, the programmer has to deal explicitly with the ambient nature of mobile ad hoc networks, in which remote references are highly volatile. This makes that enforcing restrictions on remote references is even more challenging.

  In my master's thesis, we have proposed a toolbox of software engineering abstractions that allow the programmer to organize the soup of remote references. This means that, for instance, the programmer can express that for some object, remote references can only exist for a limited amount of time. Another example is the ability to specify that remote references of a certain object are only supposed to process read operations and no write operations. Expressing these kind of restrictions enables the programmer to organize the object soup into related groups of objects.

• A first step towards enforcing access and mutate restrictions on objects (across the network) requires the ability to detect and intercept the creation of aliases. However, in ambient-oriented programming, there are no such mechanisms that provide this kind of functionality. For this reason, a first contribution of my thesis is the development of an aliasing behavioral protocol that enables to detect and intercept the creation of aliases, both locally and remotely.

  Having such aliasing behavioral protocol by itself is insufficient to organize the object soup in a way that the programmer can control which client in the network can receive a remote reference and which operations he can perform as such. Therefore, the second contribution is the reification of typestate-oriented programming in ambient-oriented applications by so called chameleon objects. Conceptually, a chameleon object behaves as a regular object, but internally it is implemented as a state machine. The interface of the chameleon object is the interface of the state wherein the state machine is transitioned in. Transitioning the state machine from one state to another occurs via regular method invocations.

  Having an aliasing behavior protocol together with chameleon objects enables to build ownership types for ambient-oriented applications. This is the third contribution of my thesis and provides the necessary abstractions to enforce access and mutate restrictions on objects across the network. This eventually enables to organize the object soup in groups of related objects depending on the restrictions they enforce. Ownership type tags can be seen as out of the box aliasing strategies that can be easily applied by the programmer in a modular fashion.

  To validate the contributions of this thesis, we have implemented WeScribble, a mobile drawing editor in which access to remotely drawn objects is controlled via ownership type tags. The implementation of this application has shown that our abstractions greatly reduce the programming effort needed to implement complex mobile applications communicating over an unreliable network.

  My master's dissertation has been conducted under the promotership of Prof. Dr. Wolfgang De Meuter. Throughout the entire research process, I was supervised and guided by Elisa Gonzalez Boix and Christophe Scholliers. Below you find the slides I presented during the defense of this dissertation. You can download my dissertation here.