European Lisp Symposium

The conference is over!


  • Compiling for the Common Case

    • Craig Zilles Craig Zilles University of Illinois (SPEAKER)

    Microprocessor vendors are actively exploring mechanisms that offer the potential to reduce the effort to produce parallel code. One such mechanism, is the ability to atomically execute code which is useful for accelerating critical sections, lock-free data structures, and for implementing transactional memory. With 3 prior implementations (Transmeta's Crusoe, Azul's Vega, and Sun's Rock) this mechanism has a lot of potential to be ubiquitous in the next decade. In this talk, I'll discuss how this mechanism can be re-purposed to provide very efficient user-mode checkpoint/rollback, allowing a compiler to generate "speculative" versions of code that support only the expected case. I'll detail our experiences exploring compiling in such an environment in the context of an x86 binary translator, a Java virtual machine, and the Python dynamic language.

  • Reconfigurable Computing on Steroids: Using Common Lisp to Generate Domain Specific Hardware

    • Marc Battyani Marc Battyani NovaSparks (SPEAKER)

    General purpose CPUs have been hitting the frequency wall but as the number of transistors in electronic chips continues to steadily increase, there is a tremendous need for other computing paradigms. One of them is the use of reconfigurable hardware (FPGA) to accelerate specific kinds of computations. Even though the performance gain can be huge, FPGAs are notoriously very difficult to program, which has been one of the major drawbacks in their adoption. There have been several attempts to solve this problem using C to VHDL/Verilog compilers. Though this can be useful at times, our opinion is that it is not a good approach. In this talk, we will explain how and why we use domain specific languages that enable us to generate high performance Domain Specific Hardware optimized for the final tasks being implemented. We will also present our experience at NovaSparks where we have been using Common Lisp to successfully define and implement those DSL->DSH compilers in financial applications since 2007.

  • Scala: an Object-Oriented Surprise

    • Apostolos Syropoulos Apostolos Syropoulos (SPEAKER)

    Scala is an OO language that was released in 2003. The distinguished features of Scala include a seamless integration of functional programming features into an otherwise OO language. Scala owes its name to its ability to scale, that is, it is a language that can grow by providing an infrastructure that allows the introduction of new constructs and data types. Scala is a compiled language. Its compiler produces bytecode for the Java Virtual Machine, thus, allowing the (almost) seamless use of Java tools and constructs from within Scala. Most importantly, Scala is a concurrent programming language, thus, it is a tool for today as well as tomorrow.


Schwarzenbergstraße 1 Building i
Hamburg 21073 Germany



Programme Chair

Local Chair

  • Ralf Moeller Ralf Moeller Hamburg University of Technology (LOCAL-CHAIR) Germany


  • António Leitão António Leitão Instituto Superior Técnico/INESC-ID (COMMITTEE) Portugal
  • Christophe Rhodes Christophe Rhodes Goldsmiths University of London (COMMITTEE) United Kingdom
  • David Liebke David Edgar Liebke Relevance Inc. (COMMITTEE) USA
  • Henry Lieberman Henry Lieberman MIT Media Laboratory (COMMITTEE) USA
  • Jay McCarthy Jay McCarthy Brigham Young University (COMMITTEE) USA
  • José Reina José Luis Ruit Reina Universidad de Sevilla (COMMITTEE) Spain
  • Manuel Serrano Manuel Serrano INRIA (COMMITTEE) France
  • Marco Antoniotti Marco Antoniotti Universita Milano Bicocca (COMMITTEE) Italy
  • Michael Sperber Michael Sperber DeinProgramm (COMMITTEE) Germany
  • Pascal Costanza Pascal Costanza Vrije Universiteit of Brussel (COMMITTEE) Belgium
  • Scott McKay Scott McKay ITA Software (COMMITTEE) USA


Times are local to the conference. You can download the programme in iCalendar format here.
  1. March 30th

  2. Welcome Reception

  3. March 31st

  4. Registration

  5. Welcome Message

  6. Compiling for the Common Case

    • Craig Zilles
  7. Coffee

  8. Supercomputing in Lisp

    • Valentin Pavlov
  9. A Futures Library and Parallelism Abstractions for a Functional Subset of Lisp

    • David Rager
    • Warren Hunt
    • Matt Kaufmann
  10. Lunch

  11. Reconfigurable Computing on Steroids: Using Common Lisp to Generate Domain Specific Hardware

    • Marc Battyani
  12. Coffee

  13. Implementing huge term automata

    • Irène Durand
  14. Jobim: an Actors Library for the Clojure Programming Language

    • Antonio Hernández
    • Maria Garcia
  15. Lightning Talks

  16. Conference Dinner

  17. April 1st

  18. Scala: an Object-Oriented Surprise

    • Apostolos Syropoulos
  19. Coffee

  20. SICL, Building Blocks for Implementers of Common Lisp

    • Robert Strandh
    • Matthieu Villeneuve
  21. Using Common Lisp in University Course Administration

    • Nicolas Neuss
  22. Lunch

  23. Bites of Lists - Mapping and Filtering Sublists

    • Kurt Normak
  24. The Scheme Natural Language Toolkit (S-NLTK): NLP Library for R6RS and Racket

    • Damir Cavar
    • Tanja Gulan
    • Damir Kero
    • Franjo Pehar
    • Pavle Valerjev
  25. Coffee

  26. Parallelizing a Commercial Common Lisp Code-Base for Performance

    • Alec Berryman
  27. The Next Lisp Challenges - Distribution, Concurrency, Parallelism

  28. Conference End


You can find the proceedings in PDF form here: