Impressions of the 2009 International Lisp Conference

The International Lisp Conference was held March 22 to 25 in Cambridge, Massachusetts. In this Tech Corner, we reproduce some of the comments about the conference and the talks sent by members of the Franz technical staff attending the conference. See the page on the ILC website for more information about the conference ( Pictures from the ILC are displayed at these locations:

These notes are quick impressions based on hearing the talk (associated papers were not looked at). It may be that the descriptions contain errors or miss essential points. We present them in part so readers can see what talks and papers they might want to know more about. Further, the conference seems to have been very successful, and these first impression indicate that success.

Monday Morning

We had one track today, it was in a large hall and had over 200 attendees.

John Amuendo (Signal Interference) demoed some sound track restoration technology using FFT transforms. Because I was late I missed the theory, but he showed an impressive restoration of the movie "The Robe", whose master was apparently lost; he showed the opening credits and the first scene, and the restoration was impressive, both sound track and picture (he said it will be available in DVD and Blu-ray in a few months).

David Rager (University of Texas, Austin) talked about a Parallelism library for a functional subset of Lisp; he talked about using ACL2 theorem prover, and described four new primitives: plet, pargs, pand, and por. He also described the "future" construct as inadequate, and described his primitives; each spawn parallel tasks if a granularity test is met and the system has (thread) resources; plet is like let but it tries to evaluate the init forms in parallel; pargs is just like funcall (he described it as being like future), but it evaluates the arguments to a function in parallel if possible, and then calls the function. Pand and por are similar to and and or, but have cross-control mechanisms for telling dependent clauses to abort when the previous one fails (or succeeds). He talked about the parallelism producers (the four primitives) and the consumers (the threads), and then discussed resource allocation heuristics. He wants a parallel gc.

Erin Fleming (2IS) presented AutoPrice; she described the project they are working on: they look for the best fair price for government bids. Manual pricing gave them a 20% "win" rate, and the first auto-pricing gave them 50% and now they are up to 60%. She gave kudos to Franz and AllegroCache, and had good answers to the questions.

Emre Sevinc (Istanbul Bilgi University) talked about their Recommendation software for online purchases (like when Amazon suggests books you might like based on what you bought). He discussed issues in looking for cross-domain recommendations; reading a book might also trigger recommending a movie, and also cross-cultural recommendations. They also wanted to provide a "why" explanation for how a recommendation came to be - discussed the ranking of relationships in nodes; the popularity of artists, producers, trombone players, etc, on a particular album contribute to form a ranking. They demoed the relationships and showed paths for surprising recommendations... the first recommendations were in Turkish so we had to take his word for it. He also showed a connection from "Fall of the House of Usher" to "Citizen Kane", apparently because Orson Wells was narrator for the former and director of the latter.

They use AllegroGraph, and gave kudos to Franz.

Robert Goldman (SIFT) talked about SHOPPER, employing a Domain Specific Language called LTML (Learnable Task Modelling Language) for web workflows. He described it as "Robo-clerk".

This application uses jlinker but will be moving to SOAP. Also it uses cl-yacc.

He outlined LTML objectives: radically composable, representable as RDF triples, no scoping, no variables, no contexts, s-expression syntax, and compatible with existing languages: OWL, OWL-S (semantic markup for web services) and PDDL (Planner Domain Description Language). He described LTML: a lisp-like hybrid language, with single-assignment variables (for concurrency). Loops are generators/reducers. and LTML maintains "belief states" about the world.

And then we had lunch...

Monday Afternoon

David Moon was guest speaker and talked about a language he's been working on for many years, called PLOT (Programming Language for Old Timers). He described it in detail, but wanted to emphasize its goals, which were cleanliness, flexibility, orthogonality, and extensibility. I have some notes from his talk, but the best source is his web page:

Joe Marshall (Google) spoke on continuations. It seems he's the one that has been working on these "trampolines" that some Schemes use to implement CPS on JVM/CLR; he's been working with Will Clinger and described his "trick". It uses the native stack; it feels very much like our "stack groups" implementation except that instead of a separate function copying out the entire stack, peeling values off the stack (and saving them elsewhere) is done by each frame's method, after which it signals the next frame to do the same. This is apparently a common technique, but Joe is working on one which doesn't require a signal to distinguish a stack-peel from a regular return. Joe has found a way to do this without using signals. He gives his web page:

Alexey Radul (MIT). He talked about "propagators", representations of programming elements via "machines" that look very much like flow diagrams, only bidirectional. He talked mostly about conflicts when two different values are calculated for a cell when coming from different directions, and described the use of partial-information and ranges to resolve and constrain the solutions.

Lightening Talks:

We had a new style of talk called a "lightening talk", which seems to have worked out very well and has been a lot of fun. The rules of the talk are thus: Guy Steele introduced the first speaker while he was setting up his laptop, for up to two minutes. He then had five minutes to talk about anything he wanted, at which time Steele called "Time" and the speaker had to immediately stop (he enforced this well). The speaker was then given two minutes to answer a couple of questions while disconnecting his laptop and allowing the next speaker to connect, after which Guy would do a quick intro to the next speaker and give him five minutes, and so on. Many speakers got cheers just for completing the talks on time, and as fast as Lispers can talk, I've never seen any talk this fast! Steele said that a perfectly acceptable question would be "can you finish your last thought?", which the audience has taken advantage of a couple of times.

Taking notes at lightening talks is hard, so here are some jottings:

Jerry Boetje: CL for Java This is a CL implementation on JVM. (looking ahead to Tuesday, he announced that it has been released and is available at

R Matthew Emmerson: Threads and GC implementation in Clozure CL. He described this as being a precise gc; there are no slots that ambiguously hold either nodes (what we call LispVals in Allegro CL) or immediates; the gc knows what it expects so it knows whether to gc it or not. This includes registers.

Brian Ericson, "Is Lisp an acceptable Ruby?" (or, Lisp through Ruby colored glasses).

8:00 - 10:00 Debate: Are Macros a Menace? The debate was a lot of fun. Guy Steele was one of the pro-macro people and Richard Gabriel one of the anti-macros (though I am not sure his heart was in that position). The debate was supposed to go to 9:00, but everyone in the audience participated and it went until we had to leave at 10:00. We gave the win to the pro-macro side, of course.

Monday was definitely a long day....

Tuesday morning

Glenn House (2IS) and Charley Cox (Franz) spoke on OASIS. Glenn started by describing Oasis as an ERP (Enterprise Resource Planning system) checker. Design Objective: "Software as a Service" - due to connection constraints, the product must live within the server. He talked about aggregating parts and scaling. He gave a video demo showing Oasis in action.

Charley talked about how Lisp is used in the UI - Allegro Webactions.

Glenn answered the question "Why Lisp?":

  1. "We like it"
  2. CLOS
  3. AllegroCache
  4. Web server (aserve)
  5. AJAX

Francios Rene-Rideaux (ITA) talked about his program XCVB (like asdf). Note: until I typed this up, I didn't realize what the name XCVB meant - I had thought it was some French acronym - but if you type asdf and then xcvb, you'll see why he chose that name. He talked about dependencies at the function/macro level. defsystems and asdf specify dependencies based on a separate file, whereas xcvb has each source file list dependencies. He gave an example of hidden missing dependencies; If file A depends on file B, file B depends on file C, and file C depends on file D, then one might specify dependency rules A<-B, B<-C, and C<-D, which would imply transitively that A<-D and D would get compiled before A. But if A actually has a dependency on D, then it is a hidden dependency because it is not specified in the rules. If then the dependency between B and C is eliminated and the B<-C rule were eliminated, then A might get compiled before D, because the hidden dependency has now become a bug.

John Hastings (University of Nebraska) talked about CARMA (Case-based Range and Management Advisor). It provides expert advice on grasshopper infestations, and analyzes economics of treatment options.

Jim Newton(Cadence Design) talked about Rhapsody. He talked about the SKILL language, talked about design of Integrated Circuits. He uses CLOS to allow extension without requiring source for the original methods. He showed an example of a cell-phone antenna coil design.He showed the class hierarchy to show inheritance of characteristics.

Jorge Vallejos (University of Brussels) talked about Reconciling Generic Functions with Actors.

Didier Verna (EPITA R/D Laboratory) is a Prof at a university in Paris. He doesn't like to have to think about performance, but his C++ colleagues do, so he must think about it. He checked C++ against CMUCL, sbcl, and Allegro CL 8.1. He is on a many-year path; this year it was structure and class instantiation. Best times for Lisps and C++ show Lisp winning over C++. He thanked the lisp maintainers.

Tuesday afternoon and evening

Gerald Sussman (MIT), Invited speaker. His topic was Evolvability and Robust Design where "robust" means "easy to change". He's willing to sacrifice correctness for robustness (sounds wrong, but he did have a point to make). He doesn't want magic bullets in software; instead he wants:

  • Additivity
  • Late Binding
  • Interchangable parts
  • Easy operation

He gave an example with a Digital abstraction, where an inverting amplifier (essentially a "not" logic gate) latches at a 1 or zero at higher/lower voltage than the signal coming in, and are not subject to the several millivolt line noise that affects the lines; generalizing, systems made out of parts whose outputs are "better" than their inputs provide noise immunity. Generalizing again, he said "For each part, expand acceptable inputs, and standardize outputs".

He showed an optical illusion where some geometric shapes made it look like there was a triangle, but there was no triangle anywhere. He argued that a system that fills in the missing details might be wrong, but in general it is a Good Thing because it allows reasoning about the world.

JonL White (the Ginger Ice Cream Factory of Palo Alto) talked about syntactic extensions to regular expression production sets in CL. Since his eyes are geting bad, he has to distill out a lot of the junk that comes with the HTML reports that he gets from time to time: banking statements, newspapers, etc. And so he has regexp productions that strip out the formatting, pop-ups, advertizing, etc. from these reports without removing the critical content. The regexps were horrendous, but the results were pretty impressive. I note that during interactions I have had with JonL after the talk, people have come up to him asking him for his regexps, because they have the same issues and get reports in similar styles.

Emendation from JonL

The showcase feature was a lispy-like extension to Regexp's which allowed boolean combinations of multiple basic search strings as Boolean filters for any pattern found, and also provided a programmable selection of different replacement patterns (GROUP-CASE). This was the only way I could handle the "hard" cases using Regexp's. And I was also trying to make the case that:

  1. Only 'content' is necessary to find the context -- forget about syntax such as XML.
  2. Always write transformations as transparent sets of regular-expression productions, not in typical full-featured programming languages which quickly become referentially UNtransparent.

More lightening talks

Bill Lewis: "Because the Debugger Knows Everything" - his premise was to be able to run the debugger backwards in time. It was obvious that he really wasn't running it backwards (to the extent that he could modify the environment and then start it running down a different path) but instead he was just rolling a virtual tape backward and forward again.

Daniel Herring talked about Lisp Distributions. Talked about BSD, Linux, Tex, Java, Perl, Python, etc., all being single-implementations, but Lisp has M implementations, N libraries. He gave a list of requirements for unification of these libraries.

Alex Plotnik talked about "Literate Programming"; Knuth says that we really program for two audiences: the computer and humans. Knuth's design called Web produces both human-readable text and machine-readable code. He showed us some WEB code and his implementation; it is written in portable CL.

Pascal Costanza talked about first class dynamic environments in web access. He demo'ed a Web page where an "old" page was dynamically loaded during which time a web developer was updating the site; the page was inconsistent. When he did the same after making a copy (like STM), it stayed the same as before (i.e. was consistent) but a new browser got the new (also consistent) page.

Tuesday evening: banquet at the Hyatt. Good food, great interaction.


Howard (Howie) Shrobe (MIT CSAIL) spoke on Toward a Secure Programming Language; an Access Control System for Common Lisp. I took a lot of notes on this one, but his paper is in the proceedings, and it is very thorough, so I'm just going to summarize the parts I noted that are not in the paper. Howie was asked to do this project and he responded that of all of the Computer Science disciplines he's done, this was the one he had never had any interest in; the reply was that that was why he was the perfect man for the job. He gave a spiel for security, talking about a system called Tiara which used the MOP to isolate subsystems into units of code with Gates and delegates; talked about potential malware and how the system was enhanced to protect itself. He got excellent questions about hacking, back-doors, "rebooting CLOS", and even Richard Gabriel got into it by suggesting that his hack would be to pay Howie off (paying off the implementor is outside the box and of course might work). Another question was how debuggers might be able to do their jobs (the answer is not very well; debug assumes openness, which reduces security).

Robert Goldman (SIFT) also spoke on security; his talk was about Intrusion Detection. He has a program called Scyllarus, He worries about false negatives less; it's the false-positives that are worrisome because it frustrates people, and causes them to turn off the security system very quickly, which defeats the purpose. He talked about various malware; "bots", bad server detection, some malware which looks like good software, and even viruses that update themselves.

He described IRM (Intrusion Reference Model) which is implemented by Scyllabus, a knowledge base with ontology of attacks, and interpretations for each IDS report. The ontology tool is Java based, and the internal data representation is S-Exprs and so it is Lisp-friendly. He described "event hypotheses", where one event would be a possible attack, and filters to figure out which ones are real.

Alex Fukunaga (Tokyo University) spoke on The Satisfyability Problem which asks the question: given a formula with sets of boolean variables, is there a set of values to set those variables so that the result of the formula is true?

Descrbed GSAT, GWSAT, WALKSAT, and Novelty/Novelty+/P-Novelty solvers for these equations, where variables are flipped and the output tested or predicted. He explored the concept of aging the variables. He described CLASS, a DSL (domain-specific language for selecting variable-selection heuristics). He compared genetic programming to be based loosely on the theory of biological evolution/selection. His major modification to all of this was to introduce PCLASS, a way to do all of this in parallel. Timings were pretty good, but not twice as much, so apparently people are still only expecting speedups from parallelism, and not expecting doublings.

Tiago Maduro Dias (University of Lisbon) spoke on Jnil: from Java to Common Lisp. Asked what good software was: complete, extensible, documented, tested. CL is a great language, but needs work on libraries. Java has libraries, but is hard to work with. His team (including Antonio Menezes Leiteao) has been reporting on this module for several ILCs, and it is looking better and better. Jnil translates from Java to CL, in the proper idioms of CL. It has an Eclipse plug-in called Eclisp. He showed the translation model.

In the afternoon, Shriram Krishnamurthi of Brown University gave the talk The Moby Scheme Compiler for Smartphones, or, Is That a Parenthesis in Your Pocket?. This was an invited speaker talk. He started out by saying that the title may be a bit misleading because he wasn't, in fact, going to talk about a scheme compiler for phones, and, indeed he wasn't even going to talk about phones for a while (and he didn't). He led up to phones by describing an afterschool program for economically disadvantaged kids where they get to write their own computer games. The program is apparently described on It is a stealth way of getting kids motivated to learn math, specifically Algebra, by having them write simple games and then make them be more complicated. One of the target platforms is Android (phones).

The language is built from plt-scheme, and the kids do their programs in scheme with a library for the graphics/game world. He had several examples showing how easy it is, with his library, to define images, move them around, and have them react to tilt, and gps locations.

Besides games, he showed how in just a few lines of scheme code, other examples, such as an app that sends mail describing where you are (using connections to google maps and gps), and remind you of tasks you may need to do on your way to somewhere (e.g, mailing a letter on your way to work).

The Computer Science part of the talk centered on the idea that programs should be written not as executables that an Operating System starts and stops, but as routines that manipulate and, importantly, return objects he calls "World" objects. These objects essentially represent what is happening on the screen (e.g., images and the velocities they're moving, etc.). The speaker says that by moving the World control into the Operating System, the Operating System decides how it should be stored, and, if appropriate, determining its mutability. In other words, the programmer is given a library to manipulate the World, but is not to be concerned with allocation or mutability.

He pointed out that the web has allowed scheme/lisp to prosper. From his slides: On the Internet, no one knows you're a Scheme program.

He further mentioned, though, that while you can have your own nice server, written in, say, Scheme, target platforms each have their own languages: Flash/ActionScript for web; J2ME; Objective-C for phones, other things for robots. He says that he can get kids excited about programming, but it is not as easy to expect them to want to learn all these other systems.

There were a lot of questions, mostly having to do with how one can improve not only Computer/Lisp/Scheme education, but education in general. He says that if kids veer away from STEM (Science, Technology, Engineering, and Math) by middle school, then it's too late to get them back in college or high school.

More lightening talks

  • Richard Greenblatt talked about hydrothermal underground vents and primordal soup.
  • John Strake spoke on Python with a Lisp - It is called Adder, it is a Lisp-1, it has defmacro, but it doesn't have cons; an Adder list is a Python list. It has CL symbols, but works and is reconciled with foo,bar.bas in Python; if started with a dot (.) it starts a function. It compiles to Python byte codes. Can't define classes yet, and can't use keyword arguments (i.e. &key). He credits Cojure for paving the way to for Lisps which integrate into an existing language. He gave a website:
  • Zach Beane talked about wigflip,com; he showed us two programs from that site, one called roflbot which allows one to add text to pictures; he showed some of his which were hilarious. Also he showed Automotivator, a motivational poster generator, which he also gave great and funny captions.
  • Ryan Culpepper (Northwest University) talked abut Debugging Hygenic macros - this is a stepper for define-syntax in Scheme; very nice GUI oriented system which hides the "real" macro expansions, with all of the lambda forms expanded.

Olin Shivers (Northwest University), invited speaker, spoke on The anatomy of a Loop: A story of Scope and Control. He started out by saying that tail-recursion is really a go-to, and he hates it; it breaks modularity, though it is a great thing as machine-code.

He showed some examples of Scheme loops where the loop and its initial value are far away, and also changing from looping over a list to looping over a vector required many changes. He suggested something closer to CL's loop, but then blasted citing the standard as stating "implementation dependent" in many places, plus Steel's and Pitman's comments about how vague the loop spec is.

He wanted to design a loop system that combines scope and control; the essence of lexical scope is that

  1. Programmers can choose any local variable names
  2. Definitions control/dominate uses (as in CL's let form, bindings control/dominate references).

He described the LTK (Loop ToolKit and CFG (Control Flow Graph) He uses cfg language like leggo blocks to build a loop construct. Each cfg block has is own scope, and both variables and jumps are local to this block with minor exceptions.

He went through the low-level design of cfg. Then he put them together into a generalize loop skeleton contruct, and started looking at various mappings of looping shapes and styles onto this model.

Some people weren't convinced that his new loop form is better than the original, though it was pretty clear that side-by-side comparison between Scheme loops and this loop construct showed his loop to be fairly flat vertically, whereas the scheme loops crept over the right-hand margin for a large function.

Copyright © 2014 Franz Inc., All Rights Reserved | Privacy Statement
Delicious Google Buzz Twitter Google+