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?

Speaker: Dave Cooper.

This was basically a walkthrough of some examples and exercises with http://gendl.com/.

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.

Speaker: Christian Quiennec

The legendary Christian Quiennec discussed a non-massive MOOC that he ran (https://programmation-recursive-1.appspot.com/course), 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)

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.

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.

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: https://github.com/fare/asdf3-2013

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.

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.

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 https://github.com/homizu/js-macro might be the github project for ExJS.

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.

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.

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 https://github.com/guitarvydas.

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

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.

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.

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, thoughthelper.com, 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.

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 https://bitbucket.org/tarballs_are_good/cl-permutation.

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: https://github.com/mbattyani/cl-fff

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: http://metamodular.com/generic-dispatch.pdf, http://metamodular.com/sliding-gc.pdf)

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 https://github.com/robert-strandh/SICL.

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.

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 cliki.net, 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 common-lisp.net which will probably be live by the time this blog post is disseminated.

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.