Join us on:

Papers 3

Directing JavaScript with Arrows
Yit Phang Khoo, University of Maryland
Michael Hicks, University of Maryland
Jeffrey Foster, University of Maryland
Vibha Sazawal, University of Maryland

JavaScript programmers make extensive use of event-driven programming to help build responsive web applications. However, standard approaches to sequencing events are messy, and often lead to code that is difficult to understand and maintain. We have found that arrows, a generalization of monads, are an elegant solution to this problem. Arrows allow us to easily write asynchronous programs in small, modular units of code, and flexibly compose them in many different ways, while nicely abstracting the details of asynchronous program composition. In this paper, we present Arrowlets, a new JavaScript library that offers arrows to the everyday JavaScript programmer. We show how to use Arrowlets to construct a variety of state machines, including state machines that branch and loop. We also demonstrate how Arrowlets separate computation from composition with examples such as a drag-and-drop handler and a bubblesort animation.

Context-oriented Software Transactional Memory in Common Lisp
Pascal Costanza, Vrije Universiteit Brussel
Charlotte Herzeel, Vrije Universiteit Brussel
Theo D'Hondt, Vrije Universiteit Brussel

Software transactional memory (STM) is a promising approach for coordinating concurrent threads, for which many implementation strategies are currently being researched. Although some first steps exist to ease experimenting with different such strategies, this still remains a relatively complex and cumbersome task. The reason is that software transactions require STM-specific dynamic crosscutting adaptations, but this is not accounted for in current STM implementations. This paper presents CSTM, an STM framework based on Context-oriented Programming, in which transactions are modelled as dynamically scoped layer activations. It enables expressing transactional variable accesses as user-defined crosscutting concerns, without requiring invasive changes in the rest of a program. This paper presents a proof-of-concept implementation based on ContextL for Common Lisp, along with example STM strategies and preliminary benchmarks, and introduces some of ContextL's unique features for context-dependent variable accesses.

Fast Type Reconstruction for Dynamically Typed Programming Languages
Frédéric Pluquet, Université Libre de Bruxelles
Antoine Marot, Université Libre de Bruxelles, Belgium
Roel Wuyts, Imec, Leuven and Katholieke Universiteit Leuven

Type inference and type reconstruction derive static types for program elements that have no static type associated with them. They have a wide range of usage, such as helping to eliminate the burden of manually specifying types, verifying whether a program is type-safe, helping to produce more optimized code or helping to understand programs. While type inference and type reconstruction is an active field of research, most existing techniques are interested foremost in the precision of their approaches, at the expense of execution speed. As a result, existing approaches are not suited to give direct feedback in development environments, where interactivity dictates very fast approaches. This paper presents a type reconstruction algorithm for any kind of variable that is extremely fast (in the order of milliseconds) and reasonably precise (75 percent). The system is implemented as a byte-code evaluator in two Smalltalk environments, and its execution speed and precision are validated on a number of concrete case studies.

Please email any questions to . This e-mail address is being protected from spambots. You need JavaScript enabled to view it