European Lisp Symposium

- 2020, Zürich
The proceedings are now online!
The conference is streamed on Twitch. More info below.

This year's online ELS will be streamed on Twitch:https://twitch.tv/elsconf

You will need a twitch account to participate in the accompanying live chat, where the Q&A will take place in the end of each talk. The chat will be always on, so you could chat during the breaks as well. There will be no video or audio for the participants. For the online event there is no other registration, and the event is free. If you follow the user elsconf on twitch you should get an email when each day's broadcast is online, 15 minutes before we actually start. During these 15 minutes just a standby image will be shown. All times in the schedule are CEST, but the video of the streams will stay online with the chat attached so you can follow the Q&As. See you soon online!

Invited Speakers

  • Andrew W. Keep (Facebook), on the Nanopass Framework.
  • Amr Abdelwahab (tourlane.com), Privilege as a technical debt.
  • Daniel Kochmański (Turtleware), on the Embeddable Common Lisp (ECL).

Highlights

  • 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.

  • Profile

    Keynote: The Nanopass Framework as a Nanopass Compiler

    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.

  • Profile

    Privilege as a technical debt

    • photo Amr Abdelwahab Amr Abdelwahab tourlane.com (SPEAKER) Germany

    Do you believe political correctness and empathy are buzzwords that limit society rather than contribute to its advancement? Do you think talking about topics like diversity quotas and privilege doesn't make much sense and you would rather spend this time talking about the latest in technology? In this talk I would like to take the chance to try and add the missing contexts to such terms and arguments, moreover, I will try to go through various examples on how it can impact your product from a very pragmatic perspective.

  • Profile

    Workshop: Mixing Mutability into the Nanopass Framework

    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.

Location

photo GZ Riesbach https://gz-zh.ch/gz-riesbach/ +41 44 387 74 50 (CONFERENCE) Seefeldstrasse 93 8008 Zürich Switzerland

Organization

Programme Chair

  • photo Ioanna Dimitriou Ioanna M. Dimitriou https://ioa.re Igalia (PROGRAMME-CHAIR) Bonn Germany

Local Chair

Committee

  • 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 SPEAKER) 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 SPEAKER) Germany
  • photo Mark Evenson Mark Evenson not.org (COMMITTEE) Austria
  • photo Max Rottenkolber Max Rottenkolber Interstellar Ventures (COMMITTEE SPEAKER) 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 SPEAKER) France
  • photo Sky Hester Sky Hester consultant (COMMITTEE) USA

Programme

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

  2. Broadcast start

  3. Welcome message

  4. Keynote: The Nanopass Framework as a Nanopass Compiler

    • Andrew 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. Sealable Metaobjects for Common Lisp

    • Marco Heisig
  9. Lunch

  10. Bidirectional leveled enumerators

    • Irène Durand
  11. Later Binding: Just-in-Time Compilation of a Younger Dynamic Programming Language

    • Max Rottenkolber
  12. Coffee Break

  13. LLVM Code Generation for Open Dylan

    • Peter Housel
  14. Indexing Common Lisp with Kythe

    • Jonathan Godbout
  15. Lightning Talks

  16. Social Event

  17. April 28th

  18. Broadcast start

  19. Workshop: Mixing Mutability into the Nanopass Framework

    • Andrew Keep
  20. Partial Evaluation Based CPS Transformation: An Implementation Case Study

    • Rajesh Jayaprakash
  21. Coffee Break

  22. Representing method combinations

    • Robert Strandh
  23. Bringing GNU Emacs to native code

    • Andrea Corallo
    • Luca Nassi
    • Nicola Manca
  24. RavenPack in the time of COVID-19

    • Andrew Lawson
  25. Lunch

  26. Privilege as a technical debt

    • Amr Abdelwahab
  27. Coffee Break

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

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

    • Marco Antoniotti
  30. Coffee break

  31. Keynote: On ECL, the Embeddable Common Lisp

    • Daniel Kochmański
  32. Lightning Talks

Proceedings

You can find the proceedings in PDF form here:

../static/proceedings/2020.pdf

Please wait...