Edmund Soon Lee Lam

Comingle: Distributed Logic Programming for Decentralized Mobile Ensembles

Comingle is a logic programming framework aimed at simplifying the development of applications distributed over multiple mobile devices. Applications are written as a single declarative program (in a system-centric way) rather than in the traditional node-centric manner, where separate communicating code is written for each participating node. Comingle is based on committed-choice multiset rewriting and is founded on linear logic. We describe a prototype targeting the Android operating system and illustrate how Comingle is used to program distributed mobile applications. As a proof of concept, we discuss several such applications orchestrated using Comingle.

Optimized Compilation of Multiset Rewriting with Comprehensions

We extend the rule-based, multiset rewriting language CHR with multiset comprehension patterns. Multiset comprehension provides the programmer with the ability to write multiset rewriting rules that can match a variable number of entities in the state. This enables implementing algorithms that coordinate large amounts of data or require aggregate operations in a declarative way, and results in code that is more concise and readable than with pure CHR. We call this extension CHR cp . In this paper, we formalize the operational semantics of CHR cp and define a low-level optimizing compilation scheme based on join ordering for the efficient execution of programs. We provide preliminary empirical results that demonstrate the scalability and effectiveness of this approach.

Decentralized execution of constraint handling rules for ensembles

CHR is a declarative, concurrent and committed choice rule-based constraint programming language. In this paper, we adapt CHR to provide a decentralized execution model for parallel and distributed programs. Specifically, we consider an execution model consisting of an ensemble of computing entities, each with its own constraint store and each capable of communicating with its neighbors. We extend CHR into CHR^<i>e</i>, in which rules are executed at a location and are allowed to access the constraint store of its immediate neighbors. We give an operational semantics for CHR^<i>e</i>, denoted <i>ω</i>₀^<i>e</i>, that defines incremental and asynchronous decentralized rewriting for the class of CHR^<i>e</i> rules characterized by purely local matching (0-neighbor restricted rules). We show the soundness of the <i>ω</i>₀^<i>e</i> semantics with respect to the abstract CHR semantics. We then give a safe encoding of the more general 1-neighbor restricted rules as 0-neighbor restricted rules, and discuss how this encoding can be generalized to all CHR^<i>e</i> programs.

Choreographic Compilation of Decentralized Comprehension Patterns

We develop an approach to compiling high-level specifications of distributed applications into code that is executable on individual computing nodes. The high-level language is a form of multiset rewriting augmented with comprehension patterns. It enables a programmer to describe the behavior of a distributed system as a whole rather than from the perspective of the individual nodes, thus dramatically reducing opportunities for programmer errors. It abstracts away the mechanics of communication and synchronization, resulting in concise and declarative specifications. Compilation generates low-level code in a syntactic fragment of this same formalism. This code forces the point of view of each node, and standard state-of-the-art execution techniques are applicable. It is relatively simple to show the correctness of this compilation scheme.

Programmable orchestration of time-synchronized events across decentralized Android ensembles

Orchestrating a time sensitive computation across an ad hoc ensemble of Android devices is surprisingly challenging in spite of the OSs support for automated network time synchronization. In fact, the lack of access to programmatic nor end-user control pushes the responsibility of implementing fine-grained time synchronization to the application development level. In this paper, we extend CoMingle, a distributed logic programming framework designed for orchestrating Android ensembles, with explicit time annotations and built-in network time synchronization support. The result is a powerful programmable orchestration framework for developing apps that exhibits time-synchronized events across an ensemble of Android devices.

Modular Multiset Rewriting

Rule-based languages are being used for ever more ambitious applications. As program size grows however, so does the overhead of team-based development, reusing components, and just keeping a large flat collection of rules from interfering. In this paper, we propose a module system for a small logically-motivated rule-based language. The resulting modules are nothing more than rewrite rules of a specific form, which are themselves just logic formulas. Yet, they provide some of the same features found in advanced module systems such as that of Standard ML, in particular name space separation, support for abstract data types, and parametrization functors in ML. Our modules also offer essential features for concurrent programming such as facilities for sharing private names. This approach is directly applicable to other rule-based languages, including most forward-chaining logic programming languages and many process algebras.