Paul Leger

AspectScript: expressive aspects for the web

JavaScript is widely used to build increasingly complex Web applications. Unsurprisingly, these applications need to address cross-cutting concerns. Therefore support for aspect-oriented programming is crucial to preserve proper modularity. However, there is no aspect-oriented extension of JavaScript that fully embraces the characterizing features of that language: dynamic prototype-based programming with higher-order functions. In this paper, we present AspectScript, a full-fledged AOP extension of JavaScript that adopts higher-order programming and dynamicity as its core design principles. In AspectScript, pointcuts and advices are standard JavaScript functions, bringing the benefits of higher-order programming patterns to define aspects. In addition, AspectScript integrates a number of state-of-the-art AOP features like dynamic aspect deployment with scoping strategies, and user-defined quantified events. We illustrate AspectScript in action with several practical examples from the realm of client Web applications, and report on its current implementation. AspectScript is a practical extension that provides better modularity support to build Web applications, and that will eventually make it possible to empirically validate the benefits brought by advanced aspect language mechanisms in an evergrowing application domain.

Modular and flexible causality control on the Web

Abstract Ajax allows JavaScript programmers to create interactive, collaborative, and user-centered Web applications, known as Web 2.0 Applications. These Web applications behave as distributed systems because processors are user machines that are used to send and receive messages between one another. Unsurprisingly, these applications have to address the same causality issues present in distributed systems like the need (a) to control the causality between messages sent and responses received and (b) to react to distributed causal relations. JavaScript programmers overcome these issues using rudimentary and alternative techniques that largely ignore the distributed computing theory. In addition, these techniques are not very flexible and need to intrusively modify these Web applications. In this paper, we study how causality issues affect these applications and present WeCa, a practical library that allows for modular and flexible control over these causality issues in Web applications. In contrast to current proposals, WeCa is based on (stateful) aspects, message ordering strategies, and vector clocks. We illustrate WeCa in action with several practical examples from the realm of Web applications. In addition, we evaluate our proposal with a third-party application and its performance.

A library to modularly control asynchronous executions

Asynchronous programming style has been widely adopted for a variety of reasons one such being the rise of Web applications. Using non-blocking operations is a major approach to enforcing asynchronous programming. A non-blocking operation requires decomposing a module that consists of a set of blocking operations into more than two modules, in turn, leading to a variety of challenges such as callback spaghetti and callback hell. This paper presents SyncAS, a library specification to address these two problems. This library specification follows the ECMAScript standard; indeed, we provide a prototype implementation for ActionScript3. SyncAS proposes a novel approach that enables programmers to virtually block a program execution and restart it at arbitrary points of the program, instead of waiting for a callback execution. As a result, programmers do not need to decompose a module even if non-blocking operations are adopted. SyncAS uses aspect-oriented programming to control the program execution in an oblivious manner.

An expressive stateful aspect language

Stateful aspects can react to the trace of a program execution; they can support modular implementations of several crosscutting concerns like error detection, security, event handling, and debugging. However, most proposed stateful aspect languages have specifically been tailored to address a particular concern. Indeed, most of these languages differ in their pattern languages and semantics. As a consequence, developers need to tweak aspect definitions in contortive ways or create new specialized stateful aspect languages altogether if their specific needs are not supported. In this paper, we describe ESA, an expressive stateful aspect language, in which the pattern language is Turing-complete and patterns themselves are reusable, composable first-class values. In addition, the core semantic elements of every aspect in ESA are open to customization. We describe ESA in a typed functional language. We use this description to develop a concrete and practical implementation of ESA for JavaScript. With this implementation, we illustrate the expressiveness of ESA in action with examples of diverse scenarios and expressing semantics of existing stateful aspect languages. We identify limitations of current stateful aspect languages.We introduce an expressive stateful aspect language in order to address these limitations.We precisely describe our proposal with a typed functional language (Typed Racket).We provide a concrete implementation of our proposal for JavaScript.In addition, we discuss a reference frame of comparison of current stateful aspect languages.

SyncAS: A Virtual Block Approach to Tame Asynchronous Programming

Asynchronous programming has been widely adopted in domains such as Web development. This programming style usually uses callback methods, non-blocking operations, allowing high responsive user interactions even if an application works without multi-threading. However, this style requires the uncoupling of a module into two sub-modules at least, which are not intuitively connected by a callback method. The separation of modules spurs the birth of other issues: callback spaghetti and callback hell. This paper proposes a virtual block approach to address the previous two issues. This approach enables a programmer to virtually block a program execution and restart it at arbitrary points in the program. As a result, programmers do not need to uncouple a module even if non-blocking operations are adopted; therefore, callback dependencies disappear. Using aspect-oriented programming, this approach uses aspects to control the execution of a program in an oblivious manner. As a consequence, programmers do not need to be concerned whether pieces of code use blocking or non-blocking operations. We implement a proof-of-concept for this approach, called SyncAS, for ActionScript3. In addition, we apply our proposal to a toy application and conduct experiments to show its modular application, flexibility, and performance.

Why do developers not take advantage of the progress in modularity

Modular software development has several benefits, such as flexibility regarding unexpected changes and increasing our ability to understand each module in isolation. Over the last few years, research on modular development has resulted in many proposals, from new abstractions to the creation of new programming paradigms. However, developers of real projects have not implemented these proposals in their daily work. In fact, in most cases, developers keep using their basic knowledge of object-oriented programming. In this poster, we discuss some possible reasons for this problem.

A self-replication algorithm to flexibly match execution traces

Stateful aspects react to the history of a computation. Stateful aspect developers define program execution patterns of interest to which aspects react. Various stateful aspect languages have been proposed, each with non-customizable semantics for matching a join point trace. For instance, most languages allow multiple matches of a sequence when the associated context information is different. Obtaining a different matching semantics requires ad hoc modifications of the aspects, if at all possible. In order to allow flexible customization of the matching semantics of a given aspect, this paper presents a self-replication algorithm called MatcherCells. Through the composition of simple reaction rules, MatcherCells makes it possible to express a wide range of matching semantics, per aspect. In addition, we present an initial implementation of our proposal.

Using an agent-based model to measure the message repetition effect on Twitter

Twitter facilitates the diffusion of information by which consumers can help companies to share their messages. However, the strategies that companies should use to reach high information diffusion are not so clear yet. Previous studies on information diffusion have focused on two issues: the type of message that companies should post for it to have more probabilities to be shared, and the type of consumers who have to engage to reach higher information diffusion. A message repetition is a novel strategy, which we assess using an agent-based simulation model for information diffusion. The model considers that consumers can reach what we term their wear-out point (i.e., where an additional message exposure leads to negative effects) when they read a tweet several times. The results of the model show the number of times a company should send the same tweet before this action has negative effects on consumers.

Sync/CC: continuations and aspects to tame callback dependencies on JavaScript handlers

In JavaScript handlers, callbacks are widely used to develop rich responsive and interactive Web applications. However, the dependency among nested callbacks, known as callback hell, can make it difficult to understand and maintain them, which will eventually mix concerns. Unfortunately, current solutions for JavaScript do not fully address the aforementioned issue. This paper presents Sync/cc, a JavaScript library that uses continuations and aspects to allow developers to write handlers that need nested callbacks in a synchronous style, preventing callback dependencies. Unlike current solutions, Sync/cc is modular, customizable, and succinct because it does not require special and scattered keywords, code refactoring, or adding ad-hoc implementations like state machines. In practice, our proposal uses a) continuations to only suspend the current handler execution until the asynchronous operation is resolved, and b) aspects to apply continuations in a non-intrusive way.

Using continuations and aspects to tame asynchronous programming on the web

In asynchronous programming of JavaScript, callbacks are widely used to develop rich interactive Web applications. However, the dependency among callbacks can make it difficult to understand and maintain pieces of code, which will mix concerns eventually. Unfortunately, current solutions for JavaScript do not fully address the aforementioned issue. This paper presents Sync/cc, a JavaScript library that uses continuations and aspects to allow developers to write asynchronous pieces of code in a synchronous style, preventing callback dependencies. Unlike current solutions, Sync/cc is modular, customizable, and succinct because it does not require special and scattered keywords, code refactoring, or adding ad-hoc implementations like state machines. In practice, Sync/cc uses a) continuations to only suspend the current handler execution until the asynchronous operation is resolved, and b) aspects to apply continuations in a non-intrusive way.