Andoni Lombide Carreton

A survey on reactive programming

Reactive programming has recently gained popularity as a paradigm that is well-suited for developing event-driven and interactive applications. It facilitates the development of such applications by providing abstractions to express time-varying values and automatically managing dependencies between such values. A number of approaches have been recently proposed embedded in various languages such as Haskell, Scheme, JavaScript, Java, .NET, etc. This survey describes and provides a taxonomy of existing reactive programming approaches along six axes: representation of time-varying values, evaluation model, lifting operations, multidirectionality, glitch avoidance, and support for distribution. From this taxonomy, we observe that there are still open challenges in the field of reactive programming. For instance, multidirectionality is supported only by a small number of languages, which do not automatically track dependencies between time-varying values. Similarly, glitch avoidance, which is subtle in reactive programs, cannot be ensured in distributed reactive programs using the current techniques.

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.

Interruptible context-dependent executions: a fresh look at programming context-aware applications

Context-aware applications provide end-users with enhanced experiences by continuously sensing their environment and adapting their behaviour to match the current context of use. However, developing true context-aware applications remains notoriously difficult due to the unpredictable nature of context changes. A context change may occur at any moment during a procedure execution, which may require an ongoing execution to be promptly interrupted in order to prevent the procedure from running in a wrong context. Currently, developers have to manually constrain a procedure execution to a particular context and take care of saving and restoring the execution state between context changes. Such manual approaches are error-prone and may lead to incorrect application behaviour. This paper presents a novel programming language model called interruptible context-dependent executions, where a procedure execution is always constrained to happen only under a specified context. In this model, a procedure execution can be seamlessly interrupted or resumed depending on the context. Additionally, the procedure execution state is automatically preserved between interruptions. We present the Flute language that supports interruptible context-dependent executions.

Loosely-coupled distributed reactive programming in mobile ad hoc networks

Pervasive applications running on mobile ad hoc networks have to be conceived as loosely-coupled event-driven architectures because of the dynamic nature of both the underlying network and the applications running on top of them. Such architectures can become tedious to develop and understand when the number of events and event handlers increases. The reason is that the control flow of the application is driven by event handlers or callbacks which are triggered independently and are scattered throughout the application code. In this paper, we propose a number of language constructs that reconcile the elegant processing of events of a reactive programming system with the loose coupling of a publish/subscribe system that is required to cope with the dynamic nature of mobile ad hoc networks.

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.

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.

Software abstractions for mobile RFID‐enabled applications

Our everyday environments may soon be pervaded with radio frequency identification (RFID) tags integrated in physical objects. These RFID tags can store a digital representation of the physical object and transmit it wirelessly to pervasive, context‐aware applications running on mobile devices. However, communicating with RFID tags is prone to many failures inherent to the technology. This hinders the development of such applications, as traditional programming models require the programmer to deal with the RFID hardware characteristics manually. On the other hand, traditional RFID middleware focuses on limited scenarios in an enterprise context and not on general ubiquitous computing scenarios. In this paper, we extend the ambient‐oriented programming paradigm to program RFID applications, by considering RFID tags as intermittently connected mutable proxy objects hosted on mobile distributed computing devices, and detail our prototype implementation. Copyright

Orchestrating nomadic mashups using workflows

Middleware for mashups is currently not able to compose the services residing in a nomadic network. Its transient connections and connection volatility result in a highly dynamic environment where services can appear and disappear at any point in time. The consequence is that these services must be discovered at runtime in an ad hoc fashion and must execute asynchronously to prevent a disconnected service to block the execution of an entire mashup. Orchestrating loosely coupled asynchronously executing services calls for a process-aware approach. This paper proposes the use of workflow patterns to enable a high level specification of the interactions between the mobile services constituting a nomadic mashup.

Ambient Clouds: Reactive Asynchronous Collections for Mobile Ad Hoc Network Applications

In MANET applications, a common pattern is to maintain and query time-varying collections of remote objects. Traditional approaches require programmers to manually track the connectivity state of these remote objects and adding or removing them from local collections on a per-object basis. Queries over these collections have to be manually recomputed whenever the collection or its elements change.

Reactive Context-Aware Programming

Using state of the art tools, context-aware applications are notified of relevant changes in their environment through event handlers which are triggered by dedicated middleware. The events signalled by the middleware should percolate through the entire application, requiring a carefully crafted network of observers combined with complex synchronization code to address the inherent concurrency issues. This paper proposes the adoption of reactive programming techniques to bridge the gap between the event-driven middleware and the application.