ELS Editions

3rd European Lisp Symposium

May 6-7, 2010,
Fundação Calouste Gulbenkian, Lisbon, Portugal

  • Wednesday, 5th May
    • 16:00–17:30
      Registration
  • Thursday, 6th May
    • 08:30–09:00
      Registration
    • 09:00–09:30
      Welcome
    • 09:30–10:30
      Keynote: Going Meta: Reflections on Lisp, Past and Future
      Kent Pitman, HyperMeta Inc. Read Bio

      Over a period of several decades, I have had the good fortune to witness and influence the design, evolution, standardization and use of quite a number of dialects of Lisp, including MACLISP, T, Scheme, Zetalisp, Common Lisp, and ISLISP. I will offer reflections, from a personal point of view, about what enduring lessons I have learned through this long involvement.

      Both the programming world and the real world it serves have changed a lot in that time. Some issues that faced Lisp in the past no longer matter, while others matter more than ever. I'll assess the state of Lisp today, what challenges it faces, what pitfalls it needs to avoid, and what Lisp's role might and should be in the future of languages, of programming, and of humanity.

    • 10:30–11:00
      Coffee
    • 11:00–12:45
      Session I (Mathematical Applications)
      • Verifying monadic second order graph properties with tree automata
        Bruno Courcelle and Irène Anne Durand
      • A DSEL for Computational Category Theory
        Aleksandar Bakic
    • 14:30–15:30
      Keynote: Reading the News with Common Lisp
      Jason Cornez, RavenPack Read Bio

      The financial industry thrives on data: oceans of historical archives and rivers of low-latency, real-time feeds. If you can know more, know sooner,or know differently, then there is the opportunity to exploit this knowledge and make money. Today's automated trading systems consume this data and make unassisted decisions to do just that. But even though almost every trader will tell you that news is an important input into their trading decisions, most automated systems today are completely unaware of the news — some data is missing. What technology is being used to change all this and make news available as analytic data to meet the aggressive demands of the financial industry?

      For around seven years now, RavenPack has been using Common Lisp as the core technology to solve problems and create opportunities for the financial industry. We have a revenue-generating business model where we sell News Analytics — factual and sentiment data extracted from unstructured, textual news. In this talk, I'll describe the RavenPack software architecture with special focus on how Lisp plays a critical role in our technology platform, and hopefully in our success. I hope to touch upon why we at RavenPack love Lisp, some challenges we face when using Lisp, and perhaps even some principles of successful software engineering.

    • 15:30–16:00
      Coffee
    • 16:00–18:00
      Session II (The Outside World)
      • Marrying Common Lisp to Java, and Their Offspring
        Jerry Boetje and Steven Melcher
      • Tutorial: Computer Vision with Allegro Common Lisp and the VIGRA Library using VIGRACL
        Benjamin Seppke and Leonie Dreschler-Fischer
    • 19:00
      Reception at the City Hall
  • Friday, 7th May
    • 09:00–10:30
      Tutorial: Parallel Programming in Common Lisp
      Pascal Costanza, Vrije Universiteit Brussel Read Bio

      Parallel programming is the wave of the future: It becomes harder and harder to increase the speed of single-core processors, therefore chip vendors have turned to multi-core processors to provide more computing power. However, parallel programming is in principle very hard since it introduces the potential for a combinatorial explosion of the program state space. Therefore, we need different programming models to reduce the complexity induced by concurrency.

      Common Lisp implementations have started to provide low-level symmetric multi-processing (SMP) facilities for current multi-core processors. In this tutorial, we will learn about important parallel programming concepts, what impact concurrency has on our intuitions about program efficiency, what low-level features are provided by current Common Lisp implementations, how they can be used to build high-level concepts, and what concepts Lispers should watch out for in the near future. The tutorial will cover basic concepts such as task parallelism, data parallelism and pipeline models; synchronization primitives ranging from compare-and-swap, over locks and software transactional memory, to mailboxes and barriers; integration with Lisp-specific concepts, such as special variables; and last but not least some rules of thumb for writing parallel programs.

    • 10:30–11:00
      Coffee
    • 11:00–12:45
      Session III (The Language)
      • CLoX: Common Lisp Objects for XEmacs
        Didier Verna
      • CLWEB: A literate programming system for Common Lisp
        Alexander Plotnick
    • 14:30–15:30
      Keynote: Lots of Languages, Tons of Types
      Matthias Felleisen, Northeastern University Read Bio

      Since 1995 my research team (PLT) and I have been working on a language for creating programming languages — small and large. Our code base includes a range of languages, and others contribute additional languages on a regular basis. PLT programmers don't hesitate to pick our lazy dialect to implement one module and to link it to a strict language for another module in the same system. Later they may even migrate one of the modules to the typed variant during some maintenance task.

      An expressive macro system is one key to this riches of languages. Starting with the 1986 introduction of hygienic macros, the SCHEME world has worked on turning macros into tools for creating proper abstractions. The first part of my talk will briefly describe this world of modern macros and its key attributes: hygiene, referential transparency, modularity of macros, phase separation, and macro specification.

      The second part of my talk will focus on how to equip LISP-like languages with a sound type systems and that will illustrate the second key idea, namely, monitoring the interactions between different languages. Our approach to type systems allows programmers to stick to their favorite LISP idioms. It mostly suffices to annotate functions and structures with type declarations during maintenance work. To ensure the soundness of this information even when higher-order values flow back and forth between typed and untyped modules, module boundaries are automatically equipped with software contracts that enforce type-invariants at all levels.

    • 15:30–16:00
      Coffee
    • 16:00–17:00
      Panel
    • 17:00–17:30
      Announcements, Symposium wrapup
    • 20:30
      Conference Banquet at "A Commenda" restaurant
  • Saturday, 8th May
    • Whole day
      (Optional) Trip to Sintra
      Read more about it here.