Christophe Scholliers

Midas: a declarative multi-touch interaction framework

Over the past few years, multi-touch user interfaces emerged from research prototypes into mass market products. This evolution has been mainly driven by innovative devices such as Apples iPhone or Microsofts Surface tabletop computer. Unfortunately, there seems to be a lack of software engineering abstractions in existing multi-touch development frameworks. Many multi-touch applications are based on hard-coded procedural low level event processing. This leads to proprietary solutions with a lack of gesture extensibility and cross-application reusability. We present Midas, a declarative model for the definition and detection of multi-touch gestures where gestures are expressed via logical rules over a set of input facts. We highlight how our rule-based language approach leads to improvements in gesture extensibility and reusability. Last but not least, we introduce JMidas, an instantiation of Midas for the Java programming language and describe how JMidas has been applied to implement a number of innovative multi-touch gestures.

Flocks: enabling dynamic group interactions in mobile social networking applications

Mobile social networking applications enable end-users to interact on the move. Current applications model user groups as simple lists which have to be manually enumerated. This representation is both unsuitable and inefficient for group interactions: due to the openness and the mobility to which these applications are exposed, the contents of such lists are likely to change frequently. Updating the lists manually while interacting with users quickly becomes impractical. In this paper, we introduce an alternative representation for user groups named flocks. A flock represents a loosely-defined user group in terms of an intensional description. The flock content is implicitly updated when changes occur, e.g. the userss location. Flocks have group interaction provisions based on asynchronous message passing. Benchmarks indicate that flocks can be implemented efficiently by exploiting structure in their definitions. We present the flock abstraction and its implementation as the basis of a new distributed framework called Urbiflock.

Fact spaces: coordination in the face of disconnection

Coordination languages for ad hoc networks with a fluid topology do not offer adequate support to detect and deal with device disconnection. Such a disconnection is particularly relevant if the device provided context information rather than emitting messages, as such context information then becomes invalid. This paper proposes the Fact Space Model which establishes a logic coordination language on top of LIMEs federated tuple space. In the model, the federated space offers applications a consistent view of their environment over which they can reason using logic rules. These rules encode which conclusions may be drawn from the presence of particular facts, and are similarly used to ensure the consistency of these conclusions when devices go out of range. By allowing applications to add application-specific hooks to these rules, the application programmer is offered a general-purpose mechanism to respond to the discovery and disconnection of devices.

AmbientTalk: programming responsive mobile peer-to-peer applications with actors

Abstract The rise of mobile computing platforms has given rise to a new class of applications: mobile applications that interact with peer applications running on neighbouring phones. Developing such applications is challenging because of problems inherent to concurrent and distributed programming, and because of problems inherent to mobile networks, such as the fact that wireless network connectivity is often intermittent, and the lack of centralized infrastructure to coordinate the peers. We present AmbientTalk, a distributed programming language designed specifically to develop mobile peer-to-peer applications. AmbientTalk aims to make it easy to develop mobile applications that are resilient to network failures by design. We describe the language׳s concurrency and distribution model in detail, as it lies at the heart of AmbientTalk׳s support for responsive, resilient application development. The model is based on communicating event loops, itself a descendant of the actor model. We contribute a small-step operational semantics for this model and use it to establish data race and deadlock freedom.

Parallel actor monitors: Disentangling task-level parallelism from data partitioning in the actor model

While the actor model of concurrency is well appreciated for its ease of use, its scalability is often criticized. Indeed, the fact that execution within an actor is sequential prevents certain actor systems to take advantage of multicore architectures. In order to combine scalability and ease of use, we propose Parallel Actor Monitors (PAMs), as a means to relax the sequentiality of intra-actor activity in a structured and controlled way. A PAM is a modular, reusable scheduler that permits one to introduce intra-actor parallelism in a local and abstract manner. PAM allows the stepwise refinement of local parallelism within a system on a per-actor basis, without having to deal with low-level synchronization details and locks. We present the general model of PAM and its instantiation in the AmbientTalk language. Benchmarks confirm the expected performance gain.

Computational contracts

Software contracts have proven to play an important role for the development of robust software. Contract systems are widely adopted in statically typed languages and are currently finding their entrance in dynamically-typed programming languages. Most research on higher-order contracts has adopted a black-box approach where only input and output are checked. These systems cannot check many interesting concerns about the behaviour of a function. Examples include prohibiting or ensuring that certain functions are called, checking access permissions, time or memory constraints, interaction protocols, etc. To address this need for behavioural runtime validation, while preserving support for higher-order programming, we introduce the notion of computational contracts. Computational contracts is a contract model with blame assignment in a higher-order setting that provides a systematic way to specify temporal contracts over objects and functions and their possibly higher-order arguments. We show various applications of computational contracts, and explain how to assign blame in case of a violation. Computational contracts have been integrated in both Scheme and AmbientTalk, a dynamically-typed object-oriented language built upon the principles of prototype-based programming.

Programming mobile context-aware applications with TOTAM

In tuple space approaches to context-aware mobile systems, the notion of context is defined by the presence or absence of certain tuples in the tuple space. Existing approaches define such presence either by collocation of devices holding the tuples or by replication of tuples across all devices. We show that both approaches can lead to an erroneous perception of context. Collocation ties the perception of context to network connectivity which does not always yield the expected result. Tuple replication can cause that a certain context is perceived even if the device has left the context a long time ago. We propose a tuple space approach in which tuples themselves carry a predicate that determines whether they are in the right context or not. We present a practical API for our approach and show its use by means of the implementation of various mobile applications. Benchmarks show that our approach can lead to a significant increase in performance compared to other approaches.

Urbiflock: An experiment in dynamic group management in Pervasive social applications

Pervasive social applications are applications that enable end users to interact and share information on the move. In these applications, the concept of a user group plays a central role as it models the users social networks. Most pervasive social applications today model these user groups as simple lists of users that have to be manually managed by the user to reflect the changes in a frequently changing context. Managing user groups in current frameworks is complicated because of three main reasons. There is a lack of abstractions (i) to discover users on the move, (ii) to organize these users in composable context-aware user groups, and (iii) to manage the communication between the users and groups of users. Our research focuses on providing proper abstractions to deal with the specific characteristics of user groups in pervasive social applications. In this paper we describe Urbiflock, a framework which aids the programmer in managing the complexity of implementing such dynamic user groups. Furthermore, we describe a messaging system called Guanotes which has been developed by means of our framework and exploits dynamic user groups to enable context-aware message propagation among mobile users.

Context-aware tuples for the ambient

In tuple space approaches to context-aware mobile systems, the notion of context is defined by the presence or absence of certain tuples in the tuple space. Existing approaches define such presence either by collocation of devices holding the tuples or by replication of those tuples across all devices. We show that both approaches can lead to an erroneous perception of context. The former ties the perception of context to network connectivity which does not always yield the expected result. The latter causes context to be perceived even if a device has left that context a long time ago. We propose a tuple space approach in which tuples themselves carry a predicate that determines whether they are in the right context or not. We present a practical API for our approach and show its use by means of the implementation of a mobile game.

The Implementation of the CHA-Q Meta-Model: A Comprehensive, Change-Centric Software Representation

Although contemporary software development processes have embraced the need for continuous change, most development tools still assume that they act upon a single complete release of the system. The CHA-Q project (Change-centric Quality Assurance) aims to strike a balance between agility and reliability through change-centric quality assurance tools. These tools are to share a first-class rep- resentation of changes to software artefacts. In this paper we present the CHA-Q meta-model that defines this representation and highlight important characteristics of its implementation: an object-oriented API, persistency through a graph database, and a strategy for tracking the history of artefacts in a memory-efficient manner.