ILC2014 summary [ilc, lisp, clojure, scheme, no-code]

When I heard that the International Lisp Conference (ILC) was happening in Montreal this year, I got very excited. Actually, I started making ambitious plans for a paper to submit and a talk to give, against which the rest of my life conspired, but I certainly registered as soon as registration opened. I've always wanted to go to ILC (and ECLM and so on), but having it happen in the city in which I live meant I had to go.

I've noticed some people on #lisp asking about the talks, so I'll try to give a brief summary of each talk, to the extent that I remember. If you have any questions, drop me a line via email, or on #lisp on Freenode IRC (my nick is tokenrove; attending ILC encouraged me to idle more).

Generally, the talks were much less technical than I had anticipated, and aimed at a very broad audience. Almost every talk seemed to run late, so I refrained from asking questions, interrogating the speakers in person during the breaks instead.

There were about 70 people, overwhelmingly male and white. There were perhaps two or three women. This was a bit of a shock for me, since other technical events I've been around lately have had much less homogeneous demographics.

In spite of my grumblings throughout this post, I have to say that the conference was overall very well organized, and my thanks go out to all the organizers.

[ILC2014 proceedings, badge, and picobot]


Luckily I was already familiar with the Université de Montréal campus, otherwise I surely would not have found the venue in time for the first talk. Later, there were posters up in a few places, which helped a bit, but initially there was no indication where this was happening. I heard from at least one other person who did miss the first talk on account of this.

Oh, and of course UdeM is built on quite a steep hill, so I imagine most people arrived a bit sweaty. It was fortunate we weren't having the kind of hot, sticky weather that often happens here this time of year.

Tutorial 1: Multiplatform and Mobile App Development in Scheme with Gambit/SchemeSpheres

Speaker: Álvaro Castro-Castilla.

The first talk was about an application framework called SchemeSpheres, which provides, among other things, modules, conditional compilation, and a unified build system.

It was nice seeing a focus on application delivery (an area where Scheme traditionally trounces CL). The demonstration was not terribly convincing, but the software itself seemed promising.

The speaker spent considerable time discussing the provision of features which CL already provides. This was the first of a recurring theme at the conference, and to me could have been discussed in the final panel: how do we increase awareness of the powerful facilities provided by CL and its ecosystem?

Tutorial 2: A Gentle Introduction to Gendl, a Common Lisp-based Knowledge Based Engineering Environment

Speaker: Dave Cooper.

This was basically a walkthrough of some examples and exercises with

It was during this tutorial that the audience was polled for CL users, and the vast majority of the attendees raised their hands.

I wanted to ask some questions about units of measure (a pet bugaboo of mine at work lately) but I think we were already running late.


The social aspects of the conference were actually the most valuable for me. Hearing about what people were working on, getting to put faces to names, and meeting new people all made the conference worth it.

Oh, and the catering was great. That always helps.


What a SOOC!

Speaker: Christian Quiennec

The legendary Christian Quiennec discussed a non-massive MOOC that he ran (, including copious statistics about participation, and the mechanics of running the course.

For me, the most interesting aspect was his discussion of automated grading. All students were required to test their code, and submit their test suite along with their implementation. The grader then checked not only whether the student's implementation satisfied its test suite, but also other combinations, as follows: (v() being the tests, and f being the implementation, s and t being student and teacher respectively)

coherence check vs(fs) and vs(ft)
correctness check vt(fs)
coverage compare vs(fs) and vt(fs)

Another interesting concept he mentioned was "epsilon-peeping"; students with incorrect solutions could be shown slightly less incorrect solutions from other students, to guide them towards correctness, and give them experience reading code.

I'm not sure if the talk is available in English anywhere, but the slides for a version in French appear to be available here.

Kilns: A Lisp Without Lambda

Speaker: Greg Pfeil.

The first talk where I had to think. Greg Pfeil presented a language he's been working on called Kilns, based on the kell calculus. There were two interesting aspects of this talk; the first was the idea of modelling locality in the language, and where that could go. I wondered whether locality could be extended "inward" instead of out – like a memory-hierarchy conscious language like Sequoia.

The second aspect was a bigger goal he described, involving a combination of educational reform and layers of languages to empower everyday programming. This reminded me a bit of some of the ideas coming out of VPRI.

Using Common Lisp as a Scripting Language

Speaker: François-René Rideau.

Fare talked about the very practical aspects he has driven forward with his work on cl-launch and newer versions of asdf. The situation for CL scripting sounds much nicer than it was even a few years ago.

There was a question about startup time from Marc Feeley, and Fare indicated that scanning for ASDF systems was the bulk of the startup time, and that it was easily eliminated by compiling the script, although he felt it was mostly negligible anyway.

You can find more of the details here:

Common Lisp's Predilection for Mathematical Programming

Speaker: Robert Smith.

An interesting talk espousing the virtues of CL as a language for numerical computation and experimental mathematics. Robert Smith showed off some code, which I understand can be obtained from his bitbucket. He demonstrated how CL provided very effective tools for succinctly expressing the constructs he needed to perform this work. It was nice to see someone fire up Emacs and show off a bunch of macros.

I asked him where he felt CL implementations should go in the future to better serve mathematicians, and he pointed me to his blog entry, Things I Want in Common Lisp. It brings up something which was another theme: everyone seems to want CL's standard library to be more generic.

Typed Clojure

Speaker: Ambrose Bonnaire-Sergeant.

I understand that the organizers put a lot of effort into trying to attract members of the Clojure community to ILC this year, but they don't seem to have been successful. Bonnaire-Sergeant was effectively the only (vocal) Clojure user I met at the conference.

He gave a talk on his work on Typed Clojure, which is directly inspired by the work of Typed Racket. It was a nice overview, but again I found myself saying to myself, "don't people know that SBCL already does a pretty good job at this? Don't people know that CL has had optional typing forever, and that declarations are great?" (Not to mention that the potential utility of declarations extends beyond just type annotations.)

It was originally supposed to be a discussion specifically of the interlanguage interoperability aspects of Typed Clojure, but Bonnaire-Sergeant decided to just describe the Typed Clojure system, given the number of attendees unfamiliar with the work.

Hygienic Macro System for JavaScript and Its Light-weight Implementation Framework

Speaker: Ken Wakita.

I wasn't too interested in this talk from the abstract, but it ended up being a great presentation. Ken Wakita presented ExJS, which I gathered was a simple, elegant implementation of macros for Javascript that actually had a very palatable syntax. Wakita was very clear about the existing work, how their work differed, and the kinds of problems they solved. One interesting thing about it is that they convert the original Javascript to s-expressions and use an existing Scheme implementation for macro-expansion.

I didn't get a URL for this, and a few seconds of trivial googling didn't help much, but might be the github project for ExJS.

An Array and List Processing System

Speaker: Dave Penkler.

This was the talk I most anticipated, because it's very closely related to work I've been doing that I had hoped to present.

Penkler presented ALPS, a fascinating rapid prototyping environment derived from Lisp and APL, including support for interactive graphics, audio, task scheduler, and probably countless other things.

This seemed to be the epitome of the personal programming environment, as unsuited to the development of stifling "enterprise" software as it is suited to maximally amplifying the output of a single programmer who knows the system intimately, like a well-worn favorite musical instrument.

He went into detail as to why he felt LISP 1.5 and APL/360 were excellent models for this kind of system, as opposed to their more modern descendents.

He demoed the obligatory Conway's Game of Life. One curiosity that was revealed out of this is that ALPS supports both APL's concept of booleans (1 and 0) as well as Lisp's (t and nil), which seems a little confusing.

ALPS does not have a type system, per se, and the set of types was intentionally kept quite simple. The sole numeric datatype is IEEE 754 double floats, not unlike Javascript. The read syntax for arrays simply uses square brackets, to indicate a vector, which can then be shaped multidimensionally with p (an ersatz ρ) if required.

GC is a simple mark-and-sweep approach, but with separate spaces for conses and vectors. I asked if he was doing any reference counting tricks (since you can often overwrite arrays in-place if you know there are no other references) but he indicated that always copying was fast enough.

ALPS has been ported across many machines and architectures; he even has it running on his phone! Penkler indicated that, at this point, having been so widely ported, ALPS' own support library is so all-encompassing that it could be run on the bare metal without any real OS support. It was originally implemented in Pascal, and later ported to C.

He indicated that he wasn't familiar with APROL, which is the main attempt of which I'm aware to blend Lisp and APL. Of course, there are other shades of that: SERIES is inspired by APL, and K is heavily inspired by Scheme (but stays, culturally, on the APL side of the fence). There are also a number of more modern attempts, particularly inspired by J and K, such as Redick, but that's a topic for a later blog post.

As far as I know, there is no public release of this system, but I exchanged contact information with Dave and I will update this page if there are any more details.

Reaching Python from Racket

Speaker: Pedro Ramos.

A technical discussion of the difficulties of reaching Python libraries which use C modules, and an approach the authors used to solving the problem for Racket. It seemed that the talk covered the same ground as the paper, although it was nice seeing the demo step-by-step.

Lightning talks 1

My memory of the lightning talks is very fuzzy, so I apologize if I have omitted your talk.

There were a couple of interesting implementation lightning talks. There was a talk on reducing the overhead of structures in Gambit scheme, and one on lazy compilation and code versioning.

There were recruitment spiels from ESS Technology and RavenPack, which I'm sure will also be posted on Lispjobs if they haven't already been.

Paul Tarvydas presented some interesting work on writing reader macros that use PEG parsers to support fancier syntax, and some experiments in flow-based programming. This work is available at

Finally, Didier Verna gave a very entertaining introduction to his :o( Smilisp :-) dialect to finish off the day.


Emacs Lisp on the Move

Speaker: Stefan Monnier.

This was the only truly universal talk at the conference. When asked who didn't use Emacs in the crowd, there was only one hand raised (and they were promptly lynched).

Monnier talked a bit about where elisp came from, some rationale for design decisions which seem painful now, and went into some depth on the efforts to improve the language. Particular advances he described in detail included lexical binding and the new advice system. He indicated that there were many things which constrained the rate of change, although that rate has been increasing in the last few years.

There was some especially interesting discussion of language features that had traditionally been slow, and how that affected the idioms and usage. Finally, there was speculation on the future, including the current progress of running elisp in Guile's VM.

A Scheme-based Closed-Loop Anaesthesia System

Speaker: Christian Petersen.

Here was a real Lisp-in-the-trenches success story. Christian Petersen described a sophisticated medical application built with Scheme, including application delivery across embedded, desktop and mobile platforms.

It was especially interesting to hear about their approach to safety certification, and his emphasis that formal verification could never entirely replace testing, since the application has to be delivered on top of millions of lines of unverified code in the OS, anyway.

People don't typically reach for a language like Scheme when building safety-critical software like this, so this is a story it would be nice to see spread to a wider audience.

The framework or development system they built in the process of building this and other systems is called LambdaNative, and is open source.

Leadership Trait Analysis and Threat Assessment with Profiler Plus

Speakers: Michael Young and Nick Levine.

The original application mentioned in the title here, and in the proceedings, was not presented, as the speakers felt a related application,, would demo better.

About half the talk was actually an introduction to the concepts of cognitive behavioral therapy, along with a demo of some of those concepts in action in the aforementioned web application. Then we got to see a few of the details of the CLOS-based NLP framework underlying it. I always hate Lisp workflows that are so "clicky" as so much LispWorks usage seems to be, but it presented nicely.

Efficient Finite Permutation Groups and Homomesy Computation in Common Lisp

Speaker: Robert Smith.

Here was another nice, REPL-driven demo of some interesting code, attached to an interesting mathematical result. I was afraid this was going to turn into an hour-long attempt to explain basic group theory, or alternately an impenetrable presentation of hyperspecialized results, but it treaded a nice middle-ground, and aside from some arguments about the phrase "bit inversions", the audience seemed appeased.

The permutation group code appears to be available at

CL-FFF: A Common Lisp Full Stack Framework for Web Apps

Speaker: Marc Battyani.

There were a lot of framework presentations at this ILC. I've used a lot of Marc Battyani's software in the past so I was eager to see this presentation. Unfortunately, I didn't find it very engaging (though I'm sure cl-fff is a fine framework for web applications); most interesting was Battyani's description of some of the commercial applications he's built in CL.

Here's a link to CL-FFF:

SICL spinoffs: Generic Dispatch, Garbage Collection, and CLOS Bootstrapping

Speaker: Robert Strandh.

This was, hands-down, my favorite talk at ILC. I guess I was expecting more talks of this nature, but this is what I came for. Strandh presented all three of the papers from the proceedings in a condensed form. (Two of those papers seem to be here:,

The generic dispatch optimization directly relates to something I'm going to be blogging about soon; I actually got into a disagreement in a job interview over this basic idea – that table-based dispatch, in general, is now often outperformed by switch-like code (carefully ordered integer comparison and branches), on modern hardware.

One question that was raised during this portion was how this approach compared with inline caches. I wanted to write something about that here but I'd better do some experiments first.

The GC approach was very cool, although I heard some grumbling from a few people about having done it before. Hendrik Boom mentioned that he had implemented a similar sliding GC in the '80s. R. Matthew Emerson mentioned that CCL has a nice mark&compact GC that no one has gotten around to writing a paper about.

The CLOS boostrapping portion discussed a technique called satiation to overcome metastability issues.

Since I've been living under a rock, I wasn't really aware of SICL, its goals, or its progress, but I find it terribly exciting, especially SICL's IR, Cleavir.

SICL, including the slides of Strandh's talk, can be found at

A Transformation Based Approach to Semantics-Directed Code Generation

Speaker: Arthur Nunes-Harwitt.

Starting from the principle of a closure as a kind of primitive code generator, Nunes-Harwitt showed a series of relatively straight-forward transformations to create a compiler out of an interpreter. He then compared the performance of the result with Norvig's well-known Prolog from PAIP. He stressed that this was a manual technique, noting that in addition to the base transformations, he had also swapped out unify with a fast union-find implementation.

This was another condensation of multiple papers, and it was relatively difficult subject matter after a long day, which may have contributed to the paucity of questions asked.

Lightning talks 2

I guess one of the more unexpected presentations was that of (if I recall the name on the slide correctly) Esposito Louis. This was a presentation by a 14-year-old of a Lisp dialect he built, including an interactive graphical frontend. It was difficult to understand exactly what was being claimed, though, since the presentation basically was a very rapid scroll through an interactive notebook that seemed to be based on Maxima, punctuated with terse exclamations of the form, "here I demonstrate mappings in the complex plane …".

Greg Pfeil gave a brief talk on Quid Pro Quo, which I knew in its former life as dbc.lisp floating around on the net. This was a great and inspiring example of the kind of curation that needs to happen in the CL community if we want to really solve the library problem.

There was a brief announcement from Dave Cooper about the Common Lisp Foundation, which promised more CL-specific meetings and other good stuff. Probably the biggest relief was hearing that the domain names, like, which have been bouncing around and renewed at the personal expense of various individuals, would finally be taken care of in a more responsible way. He also gave us a preview of a relaunched which will probably be live by the time this blog post is disseminated.

Panel: "The Next Move for Lisp"

To conclude the conference, there was a panel about the future of Lisp, comprising Fare, Christian Quiennec, Nick Levine, Dave Cooper, and Greg Pfeil. I found this discussion frustrating, and I was pretty tired, so I apologize for the misrepresentations I am bound to make in this section.

The first topic for the panel was the Lisp community. Quiennec indicated that he didn't think there was such a thing as "the Lisp community" divorced from a specific language or implementation, which seems about right. Seeing as he was the only Schemer, most of the ensuing discussion too often conflated Lisp-in-general and Common Lisp.

There was only one question in the following discussion that was actually important: "where are the Clojure people?". I don't think we got a satisfactory answer to that question.

I asked why the demographics of this conference were so skewed. I was tired by this point of the day, so my question was probably pretty incoherent, unfortunately. I was however disappointed that it was completely ignored, and never addressed.

Trying to stir up trouble, I also mentioned the Smug Lisp Weenie image (which, real or imagined, is the biggest obstacle in the Lisp community, in my opinion), but no one bit. To me, one of the reasons Clojure won big was by not being called Lisp, which allowed it to escape a lot of the baggage associated with Lisp, especially the Smug Lisp Weenie aspect.

There was some discussion of the discoverability of Lisp; evidently the lack of a canonical forum has been a difficulty for some. There was a shoutout to #lisp, and an anti-shoutout to comp.lang.lisp.

The next two sections of discussion were on Lisp in innovation, and practical directions for Lisp, if I recall correctly. In any case, the topics became blurrier as the crowd started to interject with greater frequency. The core of the innovation part was basically, "why are all the PL researchers using Haskell/ML-family languages instead of Lisp?". The last section didn't have much coherency at all, except for treading over the usual watchwords: "libraries", "documentation", "curation", "community".

Robert Strandh pointed out something very important, which was that CL and Scheme are based on standards, in an age of languages defined by de-facto canonical implementations, and that this could be a source of strength if we paid attention to that advantage.

Near the end, R. Matthew Emerson said what hopefully everyone was thinking, which was that panels like this, filled with hand-wringing, tend to be pretty depressing; that important solutions like Quicklisp come out of people deciding to solve their own problems in Common Lisp; and that the most important thing any of us can do is to just go hack more Lisp, for which he received applause from all present.

Finally, as a reward to those who stayed til the end, there was a raffle for a Scheme-driven robot, which I won! (PICO-020, pictured above) Due to the overwhelming impressiveness of Esposito Louis's talk, he was awarded a second robot.

Marc Feeley promised to send me the whole toolchain. Although he hasn't yet, I found an associated paper and repo online.

Summary: Rekindling the flame

I noticed that several people had a similar story to my own: they'd drifted away from the Lisp world over the last few years, and going to ILC was a way to rekindle that flame. That could have been a more potent topic for the panel – CL went through a spike of interest in the mid-2000s; where did those people go, and what lessons can the community learn from that?

In any case, ILC worked for me. I came away from the conference eager to return to the CL community, to better curate the libraries and tools, and most importantly, to hack more Lisp.