Dynamic Languages Symposium

For some reason I can no longer remember, I didn’t wander downstairs right away on Monday morning. Consequentially, I missed Ian Piumarta’s talk at the Dynamic Languages Symposium (official program, another one). Once I got in the room, however, I could hardly leave. It was that great.

I’ll list the presentations I saw and give some brief commentary. I’ll also link to slides, etc, when possible.

PyPy’s Approach to Virtual Machine Construction
Armin Rigo and Samuele Pedroni
http://codespeak.net/pypy

PyPy is an implementation of the Python programming language written in Python itself. I guess the idea is that a Python VM is more clearly expressed and more portable when written in Python itself (c.f. the traditional CPython). Although this gives the VM author the full expressiveness of Python, they do enforce a requirement that (after a certain phase) the VM be expressible in a restricted subset of the Python language they call RPython. The VM is then processed to generate a C interpreter (compiler?) that has better performance. Other targets include LLVM and an experimental JavaScript backend.

Runtime Synthesis of High-Performance Code from Scripting Languages
Christopher Mueller and Andrew Lumsdaine
Thesis

This talk started with a problem statement that really resonated with me: scripting languages are high-productivity, but low performance. Traditional compiled languages are high performance, but low productivity. What’s an impatient cycle-counter to do?

These guys have a set of libraries (or possibly language extensions) that allow a Python programmer to have access to the “bare metal” when it is required. Basically, it seemed like they had created a syntax for a kind of inline assembler in Python. It reminded me of something I had previously done in a JIT compiler, in order to simplify in-memory code generation.

Interlanguage Migration: From Scripts to Programs
S. Tobin-Hochstadt, M. Felleisen (Northeastern University)
http://www.ccs.neu.edu/home/samth

You’ve got to be rather brave to suggest adding static type checking to a dynamic language like Scheme. This is sure to ruffle some feathers. Sam proposes a way to add static type checking only to certain modules in a PLT Scheme program, perhaps as part of an incremental process, or possible to give some static guarantees on critical parts of an application. One interesting idea, which he and Matthias were careful not to take credit for, is the idea of a software contract with the concept of blame. In other words, when something goes wrong, this tells you which module is at fault.

This talk motivated a really cool argument between Dave Ungar (Self) and Phil Wadler (Haskell). Also Jeremy Siek and Walid Taha were pulled into the mix, due to some similar work they had done on gradudal typing (LtU reference here).

Invited Talk: Perl 6
Audrey Tang
Slides: Keynote, PDF, Flash

Short summary: wow. I haven’t been following Perl for the last few years, and a lot has happened. If there is a language feature Perl 6 doesn’t have, I haven’t heard of it. Quoting Larry Wall, “All your paradigms are belong to us…”

Some of the new goo seems somewhat Haskell-like, which might surprise you unless you know that Pugs happens to be written in Haskell. Osmosis?

Hop, a Language for Programming the Web 2.0
Manuel Serrano, Erick Gallesio, and Florian Loitsch
Article

Hop is both a web programming language and execution platform. The execution platform is a web broker which sits between the traditional client and server. You could imagine the broker running on the same machine as the client and merely freeing you from the limitations of AJAX (speed, XSS, persistence, etc). Visit the home page to see Hop in action.

Ambient References: Addressing Objects in Mobile Networks
Tom Van Cutsem, Jessie Dedecker, Stijn Mostinckx, Elisa Gonzalez Boix, Theo D’Hondt, and Wolfgang De Meuter
Project Homepage

This talk described a language for mobile devices which includes ambient references. Some references are fragile, and break immediately when a connection is lost. Others are elastic and queue up messages in the hope that connectivity will be restored. This seems appropriate for a library, but was done at the language-level.

Hardware Transactional Memory Support for Lightweight Dynamic Language Evolution
Nicholas Riley and Craig Zilles
Paper

This paper described a modification of PyPy to eliminate the global interpreter lock in favor of transactional memory. The new system was run on a simulated x86 processor with hardware TM support. Statistics such as the number of “aborts” were collected for various workloads and numbers of threads.

Invited Talk: Data Refactoring for Amateurs
Avi Bryant
Dabble DB Demo

Avi talked about his product, Dabble DB. It’s a kind of Excel / database mashup, only web-based and designed for collaboration (emailing spreadsheets around really sucks). He gave a slick demo where he began with raw tabular data and refactored it. Incidentally, Avi writes a cool blog called HREF Considered Harmful.

Advertisements


%d bloggers like this: