This collection of blog posts from Planet Lisp, dated from late March to early May 2025, covers a diverse range of topics centered around the Lisp programming language and its ecosystem. Authors share technical insights, tutorials, personal programming anecdotes, and reflections on software development practices and emerging technologies like AI. Key themes include practical Lisp programming techniques (pathnames, hashing, testing, GUI development), explorations of Lisp's unique features (macros, REPL, debugger, reader tricks), discussions on the philosophy of Lisp, comparisons with other programming paradigms, and experiences using AI for coding tasks. Tutorials focus on web development with Ningle, database integration, and environment variable management. Several posts offer historical perspectives on Lisp and its associated tools like Emacs.
Planet Lisp: Insights, Tutorials, and Reflections from the Lisp Community
Details a talk on making general-purpose hash tables faster and more robust through adaptive hashing, focusing on SBCL.
Key takeaway: SBCL hash tables (EQ and EQUAL) adapt their hashing strategy based on collision rates and key characteristics, moving from simple linear search or partial hashing to more robust functions like Murmur if needed, improving performance in common cases.
A full paper is available.
@2025-05-01 12:29 (Joe Marshall) — It Still Sucks:
Expresses frustration with persistent I/O deadlock issues in Unix when streaming input/output to subprocesses, even after decades.
Key takeaway: A Common Lisp program interacting with a database via a subprocess hangs, forcing a slow, per-record workaround.
A tutorial on integrating SQL databases (SQLite3, MySQL, PostgreSQL) with the Ningle web framework using the Mito ORM.
Important details: Covers package setup (mito, mito-auth, ingle), middleware configuration, creating models (e.g., User model with mito-auth for secure passwords), custom migration functions, and performing CRUD operations with SXQL.
Key takeaway: Provides practical steps for database interaction in a Common Lisp web application, including user registration and retrieval examples.
@2025-04-28 10:52 (Paolo Amoroso) — Adding window clearing and message printing to DandeGUI:
Updates on DandeGUI, a Common Lisp GUI library for Medley Interlisp.
Important details: Introduces GUI:CLEAR-WINDOW and GUI:PRINT-MESSAGE functions and a bug fix in GUI::WITH-WRITE-ENABLED to correctly set the file pointer.
Key takeaway: DandeGUI continues to evolve with new utility functions for text manipulation in Medley Interlisp windows.
@2025-04-27 14:33 (Joe Marshall) — Senior Programmers Have Nothing to Fear From AI:
Argues that AI will automate many junior programmer tasks but won't replace senior programmers.
Key takeaway: Senior programmers are crucial for defining tasks, crafting prompts, managing abstractions, and reviewing AI-generated code, though the pipeline for developing senior talent might be impacted.
@2025-04-26 18:00 (Nicolas Martyanoff) — Working with Common Lisp pathnames:
A comprehensive guide to Common Lisp pathnames, covering their structure, creation, and manipulation.
Important details: Explains components, make-pathname, special/invalid characters, case handling, namestrings, native namestrings, wildcards, logical pathnames (and their caveats), and recipes for common tasks like resolving paths, merging, and finding files.
Key takeaway: Pathnames are a powerful, structured way to handle file paths in Lisp, offering platform independence and logical abstractions, despite some complexities.
@2025-04-25 07:00 (Joe Marshall) — Get Over It (ai content):
An AI-generated (Gemini) vent reflecting the author's sentiment about complaints regarding Lisp's parentheses.
Key takeaway: The piece argues that an unwillingness to learn and adapt, rather than inherent difficulty, is behind such complaints.
@2025-04-24 20:52 (Marco Antoniotti) — Emacs Lisp Programming with DeepSeek: A New Widget:
Describes the creation of a new Emacs Lisp widget, dynamic-group, with assistance from the DeepSeek AI.
Important details: The widget allows dynamic addition and removal of line-like child widgets in a column. Code and a demo are provided.
Key takeaway: AI can be a helpful tool for developing Emacs Lisp components, even if the results require refinement.
An anecdote highlighting the power of the Lisp debugger.
Key takeaway: When a long-running GitHub data scraping program hit an error, the Lisp debugger allowed the author to handle the error and resume execution without losing significant work.
@2025-04-23 00:00 (Gábor Melis) — PAX and DRef v0.4:
Announces updates to PAX (documentation system) and DRef (definition reifier).
Important details: DRef now supports DTYPEs for filtering definitions. The PAX Live Home Page has improved exploration features (package grouping, apropos links, browser-based lookup). Emacs completion is enhanced.
Key takeaway: PAX and DRef continue to improve, offering better tools for Lisp documentation and code exploration.
@2025-04-21 19:17 (Paolo Amoroso) — DandeGUI, a GUI library for Medley Interlisp:
Introduces DandeGUI, a Common Lisp library for simple text and graphics output in Medley Interlisp.
Important details: It wraps Interlisp system facilities (like TEdit for text, Sketch for graphics) to provide a simpler API for window and stream management. Discusses gui:with-output-to-window and future plans.
Key takeaway: DandeGUI aims to simplify GUI development in Medley Interlisp by abstracting common patterns.
@2025-04-20 20:15 (Joe Marshall) — Well This Was Interesting:
Recounts an experiment with notebooklm.google.com, which generated a surprisingly natural-sounding podcast discussing the author's blog posts.
Key takeaway: AI-generated content is becoming increasingly sophisticated and potentially difficult to distinguish from human-created content.
Shares two Lisp reader macro tricks (tested on SBCL): one to run shell commands directly from the REPL (e.g., !ls) and another to make λ an alias for lambda.
Key takeaway: Lisp's reader macros allow for powerful and sometimes unconventional syntax customization.
@2025-04-18 06:13 (Joe Marshall) — DES Machine:
An anecdote about using an LMI Lambda Lisp Machine's extra, unaddressable register bank to store DES S-boxes by writing custom microcode.
Key takeaway: This turned the Lisp Machine into a high-speed DES cracker for password dictionary attacks, showcasing creative hardware/software co-design.
Describes using a Common Lisp ELF library and the REPL to modify an ELF binary to include both RPATH and RUNPATH entries, a task difficult with standard linkers.
Key takeaway: The Lisp environment (REPL, inspector, dynamic modification) proved highly effective for a specialized binary manipulation task.
@2025-04-13 15:35 (Joe Marshall) — Mea Culpa:
The author acknowledges that his blog posts may contain errors or oversimplifications, as they are for personal reflection and discussion, not as definitive references.
Key takeaway: Readers should approach the blog with an understanding of its informal nature.
@2025-04-13 14:54 (Joe Marshall) — Emacs and Lisp:
A personal history of using text editors, highlighting the co-evolution of Emacs and Lisp at MIT.
Key takeaway: Emacs, from its early forms to modern GNU Emacs with SLIME/Sly, has historically been deeply intertwined with the Lisp development experience.
@2025-04-12 23:37 (Joe Marshall) — Writing Your OS in Lisp:
Offers high-level hints for writing an operating system in Lisp.
Important details: Emphasizes understanding Lisp compilation, using Lisp primitives as CPU instructions, and techniques for inserting specific assembly sequences.
Key takeaway: While challenging, Lisp's compilation model and extensibility offer paths for low-level system programming.
@2025-04-11 07:00 (Joe Marshall) — Bloom Filter:
An anecdote about diagnosing a performance issue (300ms spikes) in the Google Mini search appliance.
Key takeaway: The problem was traced to an undersized Bloom filter in the spell-checking service, causing excessive false positives and slow lookups. Resizing the filter fixed the issue.
Discusses progress on "steelcut," a Common Lisp template generator, focusing on the joy and utility of writing tests in Lisp.
Important details: Created a macro with-setup to reduce boilerplate in tests. Highlights the fun aspects of Lisp programming, including LLM assistance, good books, speed, and historical significance.
Key takeaway: Lisp's macros are powerful for creating domain-specific testing utilities, making testing more concise and readable.
@2025-04-10 07:00 (Joe Marshall) — Why I Program in Lisp:
Articulates reasons for preferring Lisp despite its lower popularity.
Important details: Cites uniform syntax, ease of functional programming (substitution model, easy refactoring, lambda), powerful REPL, dynamic typing for ad hoc polymorphism, and overall "fun" as key advantages.
Key takeaway: Lisp's design as a "tool for thinking" provides a low-friction, highly customizable, and enjoyable programming experience.
@2025-04-09 11:46 (Joe Marshall) — Lisp Programs Don't Have Parentheses:
Argues that Lisp programs are fundamentally nested linked lists, with parentheses merely being their textual representation.
Key takeaway: This structural explicitness simplifies program manipulation and refactoring by editors, as Lisp expressions are context-independent.
@2025-04-07 07:00 (Joe Marshall) — Are You Tail Recursive?:
Discusses the semi-decidable nature of testing for tail recursion and provides example Lisp code for such tests.
Important details: Mentions factors that can break tail recursion (specials, multiple-value-bind, unwind-protect) and a macro (without-tail-call) to intentionally prevent it for debugging.
Key takeaway: Understanding and testing for tail call optimization is important in Lisp, as it affects stack usage and performance.
@2025-04-06 08:23 (Joe Marshall) — When Laymen Try to be Programmers:
An anecdote from Google Offers where product managers, lacking technical understanding, made decisions about email notifications that worsened user experience.
Key takeaway: Illustrates how non-technical interference in technical processes can lead to flawed solutions and unintended negative consequences.
@2025-04-04 18:18 (Joe Marshall) — Suddenly:
A brief, humorous note that Copilot is reporting Emacs and CommonLisp as top tools at the author's company, implying it's due to his own usage.
Key takeaway: Individual Lisp/Emacs enthusiasts can sometimes make a noticeable impact on tool usage metrics.
@2025-04-03 07:00 (Joe Marshall) — Blacksmithing and Lisp:
Draws an analogy between blacksmithing and Lisp programming.
Key takeaway: Customizing tools (like tongs in blacksmithing) on the fly is similar to how Lisp allows programmers to adapt the language itself to better fit the problem domain (e.g., via macros). Both involve iterative refinement and tool creation.
@2025-04-02 16:09 (Joe Marshall) — Lisp at Work:
Describes a scenario where Lisp (specifically Clojure and SBCL) was the optimal choice for a work project: migrating CircleCI builds.
Key takeaway: Despite Lisp not being a standard language at the company, its ability to interface with CircleCI's Clojure REPL and handle Lisp data structures made it ideal for this specific, temporary migration tool.
@2025-04-01 07:00 (Joe Marshall) — Vibe Coding, final word:
Recounts an experiment in guiding GPT-4o with precise instructions to write a Minesweeper clone in Common Lisp.
Important details: While the AI handled syntax well, it still made logical errors and required significant human oversight and correction. The author provided foundational code and detailed specifications.
Key takeaway: Current AI, even with detailed prompting, acts more like a parser for natural language into code, requiring careful specification and debugging, rather than possessing true programming understanding or "vibe."
A tutorial on using environment variables in Ningle projects via the cl-dotenv package.
Key takeaway: Advocates for the 12factor app methodology of storing configuration (especially sensitive data) in the environment rather than in code, and shows how to achieve this in Common Lisp.
Warns against "stringly typed" code, where objects are primarily represented and manipulated as strings, losing type safety.
Key takeaway: Recommends immediately wrapping string data (e.g., from external programs) into typed Lisp objects (like CLOS instances) to enable type checking and better program structure.