This collection of "Planet Lisp" blog posts delves into advanced Common Lisp programming techniques, critically examines the limitations and applications of Large Language Models (LLMs) in software development, and provides practical tutorials for web development in Lisp.
The Lisp-focused content highlights sophisticated error handling with handler-bind (emphasizing its stack-preserving nature), introduces adaptive hashing for performance optimization in hash tables, and discusses the nuances of Common Lisp pathnames. A significant development is the migration of Hacker News to SBCL for performance.
Conversely, several posts from "Joe Marshall" offer a skeptical but practical perspective on LLMs, detailing their failures in complex code generation (e.g., reordering functions, parsing Go grammar) and limited success in "vibe coding" (achieved primarily with Emacs Lisp due to more training data). These posts also critique Go's lack of macro systems and its error-handling conventions, arguing that LLMs might excel at generating the "bullshit" content often found in corporate management.
Tutorials by "Neil Munro" cover building web applications with the Ningle framework, focusing on database connections (SQLite, MySQL, PostgreSQL) using the Mito ORM, and implementing robust configuration switching with Envy.
Summarizing Planet Lisp Content
vindarel - Lisp error handling (advanced): how handler-bind doesn't unwind the stack (July 8, 2025)
Key Detail: Updates the Common Lisp Cookbook's "Condition Handling" page to explain handler-bind's unique property of not unwinding the stack.
Key Takeaway:handler-bind provides "absolute control over conditions and restarts," showing the full backtrace and allowing interactive or programmatic use of the debugger and restarts, unlike handler-case which unwinds the stack.
Practical Use: Essential for printing meaningful backtraces in production or manually invoking the debugger during development.
Joe Marshall - LLM failures (July 7, 2025)
Key Detail: Describes two problems LLMs (Claude Sonnet 4, Gemini-2.5) failed to solve: alphabetizing function definitions (claimed inability to determine function boundaries) and generating a functional Go parser from an extended BNF grammar.
Key Takeaway: LLMs, despite generating syntactically correct code, surprisingly struggle with seemingly simpler tasks involving structural understanding or complex parser generation, often hallucinating or getting lost.
Joe Marshall - You Are The Compiler (June 30, 2025)
Key Detail: Discusses how compilers linearize nested function calls and handle calling conventions.
Key Takeaway: Critiques Go's lack of dynamic variables and error handling, forcing programmers to manually linearize calls and check errors (e.g., if err != nil), effectively doing the compiler's job and leading to less disciplined code.
Key Detail: Part 8 of a Ningle tutorial series, focusing on mounting "sub-applications" or middleware into a main web application (e.g., an authentication system).
Key Takeaway: Mounting allows reuse of functionality across projects, simplifies modular development, and enables template layering for customized views. Provides a detailed example of creating and integrating an ningle-auth app.
Joe Marshall - No Error Handling For You (June 11, 2025)
Key Detail: Highlights the Go team's decision not to implement official error handling improvements despite recognizing the problem and receiving many suggestions.
Key Takeaway: The core issue is Go's lack of extensibility (no macro system), which prevents users from developing and choosing their own error handling libraries, leaving them stuck with built-in limitations.
Joe Marshall - Continuation-passing-style in Golang (June 10, 2025)
Key Detail: Explores implementing limited Continuation-Passing Style (CPS) in Go using first-class functions and lexical closures.
Key Takeaway: Go's lack of tail recursion causes stack overflow issues with deep CPS calls, and its distinction between value-returning and non-returning functions necessitates multiple versions of CPS routines, making the style tedious and error-prone compared to Lisp.
Joe Marshall - Generating Images (June 9, 2025)
Key Detail: Describes difficulties in persuading an image generator to create specific Lisp-related imagery (e.g., a female Common Lisp alien), often requiring multiple LLM models and explicit instructions.
Key Takeaway: Image generation with LLMs can be challenging and iterative, requiring persistence and model switching to achieve desired, nuanced results.
Joe Marshall - Avoiding Management (June 9, 2025)
Key Detail: Personal reflection on why the author prefers to be an individual contributor rather than a manager, highlighting the disadvantages (meetings, people problems, less code contact) and personal discomfort with firing.
Key Takeaway: Effective managers act as facilitators and off-board memory, handling politics and justifying realistic timelines, rather than directing activities or micromanaging. Programming provides the author with happiness and less stress.
Key Detail: Part 7 of the Ningle tutorial series, explaining how to use the envy and envy-ningle packages for simplified application configuration switching (e.g., database connections).
Key Takeaway: Separating application configuration from logic using environmental variables (like APP_ENV) makes applications more generalized, easier to manage, and adaptable across different deployment environments without code changes.
Joe Marshall - Vibe Coding, A Kind of Success (May 30, 2025)
Key Detail: Attempts "vibe coding" (generating code from vague prompts) for Minesweeper in Emacs Lisp using Claude 3.7 Sonnet.
Key Takeaway: Vibe coding proved successful in Emacs Lisp, suggesting that ample training data (available for Emacs Lisp) is a key factor. Initial errors were fixed by feeding messages back to the AI.
Joe Marshall - Dependency Injection with Thunks vs. Global Variables (May 29, 2025)
Key Detail: Explains "thunks" (functions taking no arguments, returning a value) as a safer alternative to global variables for dependency injection and sharing data between modules.
Key Takeaway: Thunks separate "what to compute" from "when to compute," provide a safer, read-only reference to values, prevent accidental dependencies, and allow values to be initialized after creation.
Joe Marshall - Vibe Coding Common Lisp Through the Back Door (May 28, 2025)
Key Detail: Describes an unsuccessful attempt at "vibe coding" Minesweeper directly in Common Lisp, followed by an attempt to vibe code in Go and then translate to Common Lisp.
Key Takeaway: Direct Common Lisp vibe coding fails due to less boilerplate and insufficient training data. Translating Go code to Common Lisp via LLM yields "fully parenthesized golang" that doesn't leverage Lisp features and often contains non-working code.
Joe Marshall - Thoughts on LLMs (May 27, 2025)
Key Detail: Shares initial impressions and exploration of LLMs, viewing them as a significant new tool in computing. Mentions using GitHub Copilot, Google Gemini, and exploring Emacs integrations.
Key Takeaway: LLMs are a "significant step forward" but have limitations. Users should learn to use them, as not doing so will be akin to not knowing how to use a web browser, and the technology is still on an "exponential growth part of the curve."
vindarel — Hacker News now runs on top of Common Lisp (May 26, 2025)
Key Detail: Announces that Hacker News, originally written in the Arc Lisp dialect, has been running on SBCL (a Common Lisp implementation) since September 2024.
Key Takeaway: The migration was driven by performance reasons, utilizing "Clarc" (Arc-to-Common Lisp compiler). While Clarc's code could be open-sourced, the full HN codebase won't be due to anti-abuse measures.
Joe Marshall - Roll Your Own Bullshit / More Bullshit / Management = Bullshit (May 25, 24, 20, 2025)
Key Detail: A series of satirical posts about corporate training, management, and LLMs. Describes a formula for creating "bullshit" corporate training courses and critiques management's tendency to generate problems or demand useless plans.
Key Takeaway: LLMs are excellent at generating "plausible sounding proposals" and "bullshit" plans (like disaster recovery) that satisfy management without requiring effort from engineers. The author prefers productive engineering work over corporate "psychobabble."
Gábor Melis - PAX PDF Output (May 15, 2025)
Key Detail: Announces PDF support for the PAX documentation system, similar in style to its HTML output, with internal and external linking.
Key Takeaway: PDF output is now available for PAX and DRef manuals, though cross-linking reliability varies across viewers.
Joe Marshall - Purchasing White Elephants (May 13, 2025)
Key Detail: Describes using an LLM to generate a plausible, expensive proposal for a bespoke software project (6 months, 15 engineers, $3M) to deter management from pursuing it.
Key Takeaway: Engineers often try to dissuade management from expensive, unnecessary custom software. LLMs can be a strategic tool to generate "horrifying" estimates that highlight the true cost of such projects.
Marco Antoniotti - Getting into a rabbit's hole and - maybe - getting out: Emacs Make Compile (EMC) (May 12, 2025)
Key Detail: Describes the development of "Emacs Make Compile" (EMC), a package for semi-transparently invoking make or cmake from Emacs on various OS.
Key Takeaway: Developing interactive Emacs commands and using the widget library is complex and poorly documented. EMC is a completed project that helps streamline build processes within Emacs, despite some "bodges."
Gábor Melis - Adaptive Hashing (May 2, 2025)
Key Detail: Discusses "adaptive hashing" for general-purpose hash tables, aiming for faster and more robust performance by adapting the hash function to actual keys.
Key Takeaway: SBCL's built-in hash tables now use adaptive hashing, improving speed in common cases (e.g., using a single shift for arithmetic sequences) and robustness against collisions by dynamically switching hash functions (e.g., to Murmur).
Joe Marshall - It Still Sucks (May 1, 2025)
Key Detail: Laments persistent I/O deadlock issues when running subprocesses and streaming data in Unix, specifically experiencing hangs after ~20 records when writing to a database.
Key Takeaway: Despite decades of development, fundamental issues like subprocess communication via streams can still be unreliable, forcing inefficient workarounds.
Key Detail: Introduces working with SQL databases (SQLite3, MySQL, PostgreSQL) in the Ningle framework using the mito ORM and mito-auth for secure password handling.
Key Takeaway: Provides step-by-step guidance on setting up database middleware, defining models (deftable), writing and executing migrations, and performing basic CRUD (Create, Read) operations for user registration, including uniqueness checks.
Joe Marshall - Senior Programmers Have Nothing to Fear From AI (April 27, 2025)
Key Detail: Argues that AI coding is highly effective for well-defined, repetitive tasks in popular languages, saving senior programmers hours of work.
Key Takeaway: AI will take over many junior programmer tasks because it's faster, consistent, and doesn't care about boredom. Senior programmers are still crucial for breaking down problems, crafting precise prompts, and reviewing AI-generated code.
Nicolas Martyanoff - Working with Common Lisp pathnames (April 26, 2025)
Key Detail: A detailed article on Common Lisp's pathname system, covering its six components, special characters, case handling, unspecific components, and namestrings (string representations of pathnames).
Key Takeaway: Pathnames are a powerful, implementation-independent, structured way to represent file paths, including wildcards and logical pathnames for location-independent file access. While initially complex, they offer advanced control for file system interactions. Caveats include confusing parsing behavior and limitations with invalid characters.
Joe Marshall - Get Over It (ai content) (April 25, 2025)
Key Detail: Uses Gemini to generate a blunt rant addressing common complaints about Lisp's parentheses.
Key Takeaway: The "too many parentheses" complaint reflects intellectual laziness and unwillingness to adapt, rather than a legitimate technical critique. Lisp's syntax directly represents the abstract syntax tree, offering power and consistency that critics miss by focusing on superficial aesthetics.
Marco Antoniotti - Emacs Lisp Programming with DeepSeek: A New Widget (April 24, 2025)
Key Detail: Chronicles the use of DeepSeek (an LLM) to help develop a dynamic-group widget for Emacs, addressing limitations of existing widget libraries.
Key Takeaway: LLMs can assist in developing complex UI components in Emacs Lisp, even with poorly documented libraries, although it may require multiple iterations and human refinement.
Joe Marshall - Lisp Debugger Wins (April 24, 2025)
Key Detail: Describes using the Lisp debugger to skip an error (due to a deleted GitHub user account) without restarting a long-running data gathering program.
Key Takeaway: The Lisp debugger's ability to "walk up the stack" and resume execution after handling an error is a powerful feature that saves significant time and work.
Gábor Melis - PAX and DRef v0.4 (April 23, 2025)
Key Detail: Announces version 0.4 of PAX (documentation system) and DRef (definition reifier), highlighting significant refactorings and new features.
Key Takeaway: New features include DTYPEs for hierarchical filtering of definitions, an improved PAX Live Home Page for in-browser exploration, and enhanced completion in Emacs.
Joe Marshall - Well This Was Interesting (April 20, 2025)
Key Detail: Experimented with Google's NotebookLM by feeding it blog posts and asking it to generate a conversation (podcast-like) and a "Deep Dive" on Tic Tac Toe.
Key Takeaway: LLMs can generate surprisingly natural and seemingly insightful content, though "tells" of AI generation exist. The quality suggests it will soon be very difficult to distinguish AI-generated text from human-written text.