ELS Editions

8th European Lisp Symposium

April 20-21, 2015
Goldsmiths University, London, UK

  • Monday April 20
    • 08:30–09:00
      Registration
    • 09:00–09:30
      Welcome messages and annoncements
    • 09:30–10:30
      Keynote I: Quicklisp: On Beyond Beta
      Zach Beane, Clozure Associates

      Quicklisp was released in 2010 as a public beta. Five years later, it's still in beta. How has Quicklisp (and Common Lisp) evolved in the past five years? What will it take for Quicklisp to go on beyond beta?

    • 10:30–11:00
      Coffee Break
    • 11:00–12:30
      Session I
      • Efficient Applicative Programming Environments for Computer Vision Applications
        Benjamin Seppke and Leonie Dreschler-Fischer
      • Keyboard? How quaint. Visual Dataflow Implemented in Lisp
        Donald Fisk
      • P2R - Implementation of Processing in Racket
        Hugo Correia and António Leitão
    • 12:30–14:30
      Lunch Break
    • 14:30–16:00
      Session II
      • Constraining application behaviour by generating languages
        Paul van der Walt
      • Processing List Elements in Reverse Order
        Irène Anne Durand and Robert Strandh
      • Executable Pseudocode for Graph Algorithms
        Breanndán Ó Nualláin
    • 16:00–16:30
      Coffee Break
    • 16:30–17:30
      Keynote II: Unwanted memory retention
      Martin Cracauer, Google

      This talk goes over numerous oddities in a Lisp-based system which led to unwanted heap memory retention and to constant resident memory growth over the uptime of the system. Issues covered include a mostly conservative but also paged garbage collector, the difficulty of clearing out data structures that are retainted as an optimization but that might hold on to large amounts of heap (and how that happens in C++, too) and how large intercollected and theoretically uprooted "clouds of heap debris" interact with stale pointers out of same. The most delicious pieces center around pointer staleness out of the saved (on-disk, but read-write mapped) part of the heap, which is not garbage collected, into anonymous memory backed heap and how you can create rootless but uncollected and "untraceable" object circles. Untraceable until you hack up the GC to help you.

    • 17:30–18:00
      Lightning Talks
    • 19:30
      Conference Dinner
  • Tuesday April 21
    • 09:30–11:00
      Tutorial: A Gentle Introduction to Gendl, a Common Lisp-based Knowledge Based Engineering Environment
      Dave Cooper
    • 11:00–11:30
      Coffee Break
    • 11:30–12:30
      Session III
      • lambdatalk
        Alain Marty
      • Symbolic Pattern Matching in Clojure
        Simon Lynch
    • 12:30–13:00
      Sponsored Talk: Escaping the Heap
      Ahmon Dancy, Franz Inc.

      Common Lisp implementations provide great automatic memory management of data structures. These data structures are allocated from a memory area called the “heap”. However, there are times when heap allocation is inadequate to satisfy the needs of the application. For example, sometimes data structures need to be persistent or shareable amongst separate processes. In these cases, alternatives to using the heap must be considered.

      In this talk we will explore the motivations for out-of-heap data structures. We will discuss some of the out-of-heap data structures that we’ve created in the course of developing our database product, such as lists, hash tables, and arrays. We will describe the tools and mechanisms that we used to implement them, including memory-mapped files, foreign structs, aligned pointers and direct memory accesses. Finally we will discuss the downsides of out-of-heap data structures and the constant struggle between abstractions and performance.

    • 13:00–14:30
      Lunch Break
    • 14:30–15:30
      Keynote II: µKanren: Running the Little Things Backwards
      Bodil Stokke

      Relational programming, or logic programming, is a programming paradigm that exhibits remarkable and powerful properties, to the extent that its implementation seems frightfully daunting to the layman. µKanren is a minimal relational language that seeks to strip the paradigm down to its core, leaving us with a succinct, elegant and above all simple set of primitives on top of which we can rebuild even the most powerful relational constructs.

      In this talk, we will explore the µKanren language by implementing it from first principles in a simple functional programming language, going on to demonstrate how you can assemble these simple building blocks into a semblance of its richer parent, miniKanren, and maybe solve a logic puzzle or two to make sure it’s working as advertised.

      The µKanren paper, and the original µKanren implementation, were authored by Jason Hemann and Daniel P. Friedman. Here are the paper and the Scheme implementation .

    • 15:30–16:00
      Coffee Break
    • 16:00–17:30
      Session IV
      • Woo: a fast HTTP server for Common Lisp (Demonstration)
        Eitaro Fukamachi
      • Clasp: Common Lisp+LLVM+C++
        Christian Schafmeister
      • Quantum Physics Simulations in Common Lisp
        Miroslav Urbanek
      • First-class Global Environments in Common Lisp
        Robert Strandh
    • 17:30
      Lightning Talks, wrapup, goodbyes