Skip to content

Instantly share code, notes, and snippets.

@jwalsh

jwalsh/els2025-executive-summary.md

Last active May 20, 2025 14:29
Show Gist options
  • Save jwalsh/c98d80589034af3e89401d7dec7310b6 to your computer and use it in GitHub Desktop.
Save jwalsh/c98d80589034af3e89401d7dec7310b6 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
els2025-executive-summary.md

European Lisp Symposium 2025 Summary

Overview

The European Lisp Symposium 2025 was held in Zürich, Switzerland on May 19-20, featuring presentations on modern Lisp applications, language design, and AI integration. This report summarizes key presentations and insights relevant to technical teams.

Recordings

Key Presentations

Day 1 Highlights

Project Oberon: A Late Appraisal

Jürg Gutknecht, ETH Zürich | Timestamp 0h16m45s

  • Operating system designed for simplicity and coherence on custom RISC hardware
  • Demonstrated influence on modern minimalist system design
  • Project Documentation | Full PDF

Coalton: Safe Software in Common Lisp

Robert Smith | Timestamp 4h17m10s

  • Statically typed functional programming language embedded in Common Lisp
  • Combines Haskell-like type safety with Lisp's flexibility
  • Currently implementing type-safe conditions and restarts
  • GitHub Repository

The Lisp in the Cellar: Dependent Types that Live Upstairs

Pierre-Évariste Dagand & Frédéric Peschanski | Timestamp 6h01m15s

  • "Deputy": Clojure-hosted dependently-typed programming language
  • Enables REPL-driven development workflow during type checking
  • Symbolic debugging of type errors using Clojure/Cider tooling
  • Addresses challenges of embedding dependent types in a dynamic language
  • Paper | GitLab Repository

Programming with Useful Quantifiers (HeavyBool)

Jim Newton | Timestamp 6h59m21s

  • "Heavy-Boolean": Objects that act as boolean but carry metadata
  • Implementation of universal and existential quantifiers
  • Demonstrated counterexample detection capabilities
  • Paper | GitHub Repository

Day 2 Highlights

Is Lisp Still Relevant in the New Age of AI?

Anurag Mendhekar | Timestamp 0h25m00s

  • Examined Lisp's role in modern AI landscape
  • Discussed symbolic AI approaches and their integration with neural networks
  • Reflected on Lisp's historical contributions to AI and current opportunities

Deep Learning Using Common Lisp

Martin Atzmueller | Timestamp 1h55m00s

  • Integration of deep learning techniques with Common Lisp
  • Introduction to LISP-GNN (Lisp Interface for Semantic Processing with Graph Neural Networks)
  • Explored explainable AI implementations in Lisp
  • Personal Website | Publication List

Porting SBCL to Nintendo Switch

Charles Zhang & Yukari Hafner | Timestamp 4h10m00s

  • Adapted Steel Bank Common Lisp to run on Nintendo Switch (ARM64 platform)
  • Overcame challenges: no dynamic memory marking as executable, no thread signal handlers
  • Used "shrinkwrapping" technique to prepare static executables
  • Paper

Lisp and AI Round Table

Panel Discussion | Timestamp 4h55m00s

Key Topics:

  • Neural network hermeneutics - extracting features from neural networks
  • Neuro-symbolic AI integration strategies
  • AI's "addiction" to REPL environments
  • LLMs' challenges with Lisp code generation
  • Retrieval-Augmented Generation (RAG) for AI systems

Notable Resources:

Technical Trends Observed

  1. Type Safety in Lisp Ecosystems

    • Growing interest in statically typed Lisp variants (Coalton)
    • Dependent types integration with dynamic languages (Deputy)
    • Type-safe constructs that preserve Lisp's flexibility

  2. AI and Lisp Integration

    • Neuro-symbolic approaches gaining renewed attention
    • Lisp as glue language for AI system components
    • Challenges and opportunities in LLM-generated Lisp code

  3. Modern Runtime Environments

    • Expanding Lisp to restricted platforms (Nintendo Switch)
    • Cross-compilation and deployment strategies
    • Novel garbage collection approaches for constrained environments

  4. Educational Approaches

    • "Growing Your Own Lispers" experience report
    • Adapting Lisp teaching to modern programming contexts
    • Connecting historical Lisp concepts to contemporary challenges

Implications for Our Team

[Your notes on relevance to your team's work with AI/Lisp/Clojure/Scheme/Hy can be added here]

Raw
els2025-lightning-talks.md

ELS 2025 Lightning Talks

Overview

Summary of lightning talks presented at the European Lisp Symposium 2025.

Talks by Presenter

  1. Dave Cooper

    • Lispy MCP: Implementation of Model Context Protocol for Lisp environments
    • Skewed Emacs: Comprehensive configuration for Emacs optimized for Lisp/Gendl development

  2. Philipp Marek

    • User-Defined Integer Types for SBCL

  3. Kimberley Prause

    • Problems in Communication between Clients and Developers
    • Theme: "bip - business in progress"

  4. Julius Borghardt

    • Being Part of STK

  5. Arthur Evensen

    • Reinventing the Wheel

  6. Robert Strandh

    • SICLy Related Libraries

  7. Artyom Bologov

  8. Max Rottenkolber

    • Webkit / JavaScript Core

  9. Fernando Guigou

    • Application Base Demo

  10. Christophe Rhodes

    • Continuous Integration of SBCL / a Release Manager's Plea

  11. Yukari Hafner

    • Weiss

  12. Faré

    • The Best of Multiple and Single Inheritance

MCP (Model Context Protocol) Highlights

  • Means for exposing software tools to AI
  • Bidirectional integration between AI models and Lisp using S-expressions
  • Reference implementation in Claude Desktop
  • Growing ecosystem of clients (OOlama, Emacs) and servers

Key Projects

  • Skewed Emacs: github.com/gornskew/skewed-emacs

    • Terminal-mode Emacs for Lisp/Gendl
    • SLIME setup, AI integration, MCP server

  • Problems in Communication: Client-Developer misunderstandings and solutions

graph TD
    ELS[ELS 2025 Lightning Talks] --> Day1[Day 1 - May 19]
    ELS --> Day2[Day 2 - May 20]
    
    Day1 --> CI[Continuous Integration of SBCL]
    Day1 --> Weiss[Weiss]
    
    Day2 --> MCP[Lispy MCP]
    Day2 --> Emacs[Skewed Emacs]
    Day2 --> SBCL[User-Defined Integer Types for SBCL]
    Day2 --> Comm[Problems in Communication]
    Day2 --> STK[Being Part of STK]
    Day2 --> Wheel[Reinventing the Wheel]
    Day2 --> SICL[SICLy Related Libraries]
    Day2 --> Lambda[CL Lambda Calculus Compiler]
    
    MCP --> AI[AI Integration]
    Emacs --> Config[Emacs Configuration]
Loading
Raw
els2025.md

European Lisp Symposium 2025 - Summary

Conference Details

Live Streams

Day 1 Recordings with Timestamps

Time (UTC+2) Session Twitch Link
09:45 Welcome and Announcements Welcome (0h02m30s)
10:00 Keynote: Project Oberon Project Oberon (0h16m45s)
11:45 Experience: Growing Your Own Lispers Growing Your Own Lispers (2h15m29s)
14:00 Keynote: Safe Software in Common Lisp Coalton in Common Lisp (4h17m10s)
15:45 Paper: The Lisp in the Cellar The Lisp in the Cellar (6h01m15s)
16:30 Paper: Programming with Useful Quantifiers HeavyBool Presentation (6h59m21s)
17:30 Lightning Talks Lightning Talks (7h48m00s)

Day 2 Estimated Timestamps

Time (UTC+2) Session Estimated Twitch Link
09:30 Announcements Announcements (est. 0h10m00s)
09:45 Keynote: Is Lisp Relevant in AI? Lisp in AI (est. 0h25m00s)
11:15 Paper: Deep Learning Using Common Lisp Deep Learning in CL (est. 1h55m00s)
13:30 Experience: SBCL on Nintendo Switch SBCL on Nintendo Switch (est. 4h10m00s)
14:15 Round Table: Lisp and AI Lisp and AI Panel (est. 4h55m00s)
15:45 Lightning Talks Lightning Talks (est. 6h25m00s)
16:15 Hackathon Hackathon (est. 6h55m00s)

Notes and References

Project Oberon

Growing Your Own Lispers

  • Authors: Michał Herda and Wojciech Gac
  • Format: Experience Report

Toward safe, flexible, and efficient software in Common Lisp (Coalton)

  • Author: Robert Smith
  • Repository: github.com/coalton-lang/coalton
  • Description: Statically typed functional programming language that supercharges Common Lisp

The Lisp in the Cellar - Dependent Types that Live Upstairs

Session Notes

  • Presentation introduces Deputy, a Clojure-hosted dependently-typed programming language
  • Key innovation: REPL-driven interactive development workflow during type checking
  • Symbolic debugging of type errors using Clojure/Cider tooling
  • Implementation of inductive families in a Lisp environment
  • Demo shows how to debug type errors interactively
  • Paper explores embedding dependent types within Lisp's interactive environment

Programming with Useful Quantifiers (HeavyBool)

Session Notes

A Heavy-Boolean is an object which should be treated as a true or false in a Boolean context, but has some meta-data attached to it. The motivating example is to implement universal and existential quantifiers.

  • Presentation starts at 6h59m21s
  • Demo of counterexample detection: 7h12m15s
  • Implementations in multiple languages: 7h18m30s

Is Lisp Still Relevant in the New Age of AI?

  • Author: Anurag Mendhekar (Paper Culture LLC)
  • Format: Keynote

A Brief Perspective on Deep Learning Using Common Lisp

Lisp and AI Round Table

  • Participants: Anurag Mendhekar, Martin Atzmueller, Vsevolod Domkin, Gábor Melis, Dave Cooper

Key Concepts and Topics Discussed

  1. Neural network hermeneutics - Extracting features/heuristics from neural networks for use in deterministic programming systems
  2. Symbolic approaches for LLMs - Using symbolic approaches to augment LLM reasoning capabilities
  3. Neuro-symbolic AI - Established research field, with IBM's work highlighted
  4. Integration of conventional systems with LLMs:
    • WolframAlpha API for LLMs
    • MCP protocol for integrating traditional systems (including GOFAI) with LLMs
  5. AI "addiction" to REPL - Discussion about how AI models seem to become "addicted" to the Read-Eval-Print Loop
  6. Lisp-specific AI challenges - LLMs struggle with generating Lisp code, particularly with scoping rules and user-defined macros
  7. RAG (Retrieval-Augmented Generation) - Discussed in context of vector databases

Papers and Resources Mentioned

  1. Research paper: AI "addiction" to REPL
  2. Book: Marx and the Robots: Networked Production, AI and Human Labour
  3. Fiction reference: Asimov's "The Feeling of Power" - Referenced in discussion about the future of coding
  4. Concept source: "Metahuman hermeneutics" by Ted Chiang - Inspiration for the "neural network hermeneutics" term
  5. Video resource: Presentation on crystallization/automatic definition function (around 31:55)
  6. LLM tools: Perplexity.ai - Example of an LLM-powered search engine

Porting SBCL to Nintendo Switch

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment