European Lisp Symposium

- 2020, Zürich
#COVID-19: physical event cancelled / fully refunded. Stay tuned for updates.
Preliminary programme and keynote abstracts now online.


This year's focus will be directed towards "Compilers".

We especially invite submissions in the following areas:

  • Compiler techniques
  • Compiler passes
  • Compiler compilers
  • Showcasing of industrial or experimental compilers
  • Code generation
  • Compiler verification
  • Compiler optimizations
  • JIT compilers

Contributions are also welcome in other areas, including but not limited to:

  • Context-, aspect-, domain-oriented and generative programming
  • Macro-, reflective-, meta- and/or rule-based development approaches
  • Language design and implementation
  • Language integration, inter-operation and deployment
  • Development methodologies, support and environments
  • Educational approaches and perspectives
  • Experience reports and case studies

We invite submissions in the following forms:

  • Papers: Technical papers of up to 8 pages that describe original results or explain known ideas in new and elegant ways.
  • Demonstrations: Abstracts of up to 4 pages for demonstrations of tools, libraries, and applications.
  • Tutorials: Abstracts of up to 4 pages for in-depth presentations about topics of special interest for at least 90 minutes and up to 180 minutes.

You can upload submissions on EasyChair.

All submissions should be formatted following the ACM SIGS guidelines and include ACM Computing Classification System 2012 concepts and terms. Appropriate TeX and Word templates can be found on the ACM publications page.

LaTeX submissions are encouraged. For LaTeX submissions, please use the SIGCONF style (two columns, reasonably compact). This is done like this: \usepackage[format=sigconf]{acmart}.

Please use the ACM Computing Classification System site to generate the CCS codes. In order to add a concept, navigate to it using the boxes, and select "Assign This CCS Concept" on the left side. You should select one high relevance concept, and up to four medium or low relevance concepts. Once you are done, simply copy the CCS display into the Word document. If you are using TeX, select "View CCS TeX Code" and copy the displayed code into your TeX file. The templates should already include sections with bogus CCS codes, which you can simply replace with your own.

If you are using the correct style and classification system, your document will contain a section called CCS Concepts and include terms formatted like •Information systems → Web applications. If your document includes a section titled Categories and Subject Descriptors with things in a style like D.2.3 [Software Engineering]: Coding Tools and Techniques, then you have to update to the new 2012 system and templates as linked above. If the CCS section does not show up in the TeX generated PDF at all, make sure that your TeX file includes the \printccsdesc command below the abstract.


Invited Speakers

  • Andy Keep (Cisco Systems, Inc.), on the Nanopass Framework.
  • Daniel Kochmański (Turtleware), on the Embeddable Common Lisp (ECL).


  • Profile

    Keynote: On ECL, the Embeddable Common Lisp

    Embeddable Common Lisp is a Common Lisp implementation with historical roots dating back to 1985 when Kyoto Common Lisp was released as an open source project by Taichi Yuasa and Masami Hagiya. It is one of the first Common Lisp implementations predating the ANSI standard (CLtL1) and it has influenced its final version. First developed by academia, then by volunteers from the free software community, it still thrives as one of many actively developed Common Lisp implementations. Thanks to a portable and small core it is possible to embed ECL in other applications as a shared library. This property enables Common Lisp programmers to develop their applications and plugins as an extension to existing software and to use Common Lisp software on platforms like Android and iOS. Executables and libraries built with ECL are small and suitable for writing utilities and libraries used by applications outside of the Common Lisp world. Maintaining and improving a Common Lisp implementation is a challenging and fun task with many opportunities to learn about software and compilers. During this presentation I'll talk about the past, the present, and the future of ECL. I'll discuss its heritage, then move to its current architecture with its flaws and advantages, and I will finish with my plans for further development.

  • Keynote: The Nanopass Framework as a Nanopass Compiler

    • photo

    The nanopass framework is a domain specific language for defining compilers that provides two basic syntactic forms: define-language and define-pass. The define-language form defines the grammar for an intermediate representation and can either define the full language or extend an existing language. Language forms are represented using Scheme records and a parser and unparser can be constructed from the language definition to move between S-expression and nanopass language form representations. The define-pass form defines procedures for operating over these language forms, based on the specified input and output languages. In addition to these two basic forms, a number of small tools for interacting with languages exist, including tools for extracting the define-language syntactic form for a language, making it easier to see the full language when it was defined as an extension, along with tools for differencing two languages to produce the language extension form, pruning unreachable nonterminals, and defining a procedure for counting nodes in a language form for a given language. These tools are helpful, but we can imagine wanting more tools, for instance a tool to generate a equivalence procedure over language forms or a tool to generate a procedure for computing a histogram of nonterminal node types in a language form. Unfortunately, each tool must be written with knowledge of the internals of the nanopass framework. What if the nanopass framework instead provided an API for writing these extensions? What if the define-language and define-pass forms, were defined as nanopass languages that could be treated like other nanopass languages? How much of the nanopass framework could be written using the nanopass framework? This talk will explore this experiment.

  • Workshop: Mixing Mutability into the Nanopass Framework

    • photo

    Languages defined using the nanopass framework are represented using immutable Scheme records [1], however, it can be useful to have mutable cells with the terminals of a language form. For instance, the Chez Scheme compiler represents each variable as a single Scheme record instance. This means the binding site and all use sites for a given variable all use the same record instance to represent that variable. The variable record contains mutable fields which allow information from variable uses to be visible at the binding site and vice versa. For instance, variable uses can report whether they are referenced, multiply referenced, or assigned to the variable binding site, or the variable binding site can record information needed at the use sites for a variable without constructing an environment within the pass. This workshop will give a brief introduction to the nanopass framework using an example compiler for a small subset of Scheme, and then look at how this technique is used for converting assigned variables and computing free variable sets in lambda expressions. [1] In addition to immutable records, standard (and hence mutable) Scheme lists are used for for representing lists within a language form, but the expectation is that these lists will not be mutated.


photo GZ Riesbach +41 44 387 74 50 (CONFERENCE) Seefeldstrasse 93 8008 Zürich Switzerland


Programme Chair

  • photo Ioanna Dimitriou Ioanna M. Dimitriou Igalia (PROGRAMME-CHAIR) Bonn Germany

Local Chair


  • photo Andy Wingo Andy Wingo Igalia (COMMITTEE) France
  • photo Asumu Takikawa Asumu Takikawa Igalia (COMMITTEE) USA
  • photo Charlotte Herzeel Charlotte Herzeel Imec, ExasSience Lab (COMMITTEE) Belgium
  • photo Christophe Rhodes Christophe Rhodes Google (COMMITTEE) UK
  • photo Irène Durand Irène Durand Université de Bordeaux (COMMITTEE) France
  • photo Jim Newton Jim Newton EPITA Research Lab (COMMITTEE) France
  • photo Kent Pitman Kent Pitman HyperMeta (COMMITTEE) USA
  • photo Leonie Dreschler-Fischer Leonie Dreschler-Fischer University of Hamburg (COMMITTEE) Germany
  • photo Marco Heisig Marco Heisig FAU Erlangen-Nürnberg (COMMITTEE) Germany
  • photo Mark Evenson Mark Evenson (COMMITTEE) Austria
  • photo Max Rottenkolber Max Rottenkolber Interstellar Ventures (COMMITTEE) Germany
  • photo Metin Evrim Ulu Metin Evrim Ulu Middle East Technical University (COMMITTEE) Turkey
  • photo Paulo Matos Paulo Matos Igalia (COMMITTEE) Germany
  • photo Robert Goldman Robert Goldman SIFT (COMMITTEE) USA
  • photo Robert Strandh Robert Strandh Université de Bordeaux (COMMITTEE) France
  • photo Sky Hester Sky Hester consultant (COMMITTEE) USA


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

  2. Registration

  3. Welcome message

  4. Keynote: The Nanopass Framework as a Nanopass Compiler

    • Andy Keep
  5. Coffee Break

  6. Omnipresent and low-overhead application debugging

    • Robert Strandh
  7. An R7RS Compatible Module System for Termite Scheme

    • Frédéric Hamel
    • Marc Feeley
  8. LLVM Code Generation for Open Dylan

    • Peter Housel
  9. Lunch

  10. Sealable Metaobjects for Common Lisp

    • Marco Heisig
  11. Later Binding: Just-in-Time Compilation of a Younger Dynamic Programming Language

    • Max Rottenkolber
  12. Coffee Break

  13. Bidirectional leveled enumerators

    • Irène Anne Durand
  14. Indexing Common Lisp with Kythe

    • Jonathan Godbout
  15. TBA

    • TBA
  16. Lightning Talks

  17. Social Event

  18. April 28th

  19. Registration

  20. Keynote: On ECL, the Embeddable Common Lisp

    • Daniel Kochmański
  21. A portable, annotation-based, visual stepper for Common Lisp

    • João Távora
  22. Coffee Break

  23. Workshop: Mixing Mutability into the Nanopass Framework

    • Andy Keep
  24. Partial Evaluation Based CPS Transformation: An Implementation Case Study

    • Rajesh Jayaprakash
  25. Lunch

  26. Representing method combinations

    • Robert Strandh
  27. Why You Cannot (Yet) Write an "Interval Arithmetic" Library in Common Lisp -- or: Hammering Some Sense into :ieee-floating-point

    • Marco Antoniotti
  28. Coffee Break

  29. JACL: A Common Lisp for Developing Single-Page Web Applications

    • Alan Dipert
  30. Bringing GNU Emacs to native code

    • Andrea Corallo
    • Luca Nassi
    • Nicola Manca
  31. TBA

    • TBA
  32. Lightning Talks

Please wait...