Reading "A Programmer's Guide to Common Lisp"

Original Article ↗ Hacker News Discussion ↗

Common Lisp enthusiasts reflect on how to learn and work productively in the language, contrasting the line-oriented REPL with tools like IPython and recommending editor-integrated environments such as Emacs+SLIME, Vim+VLIME, or even Jupyter-based setups for interactive development. Much of the exchange centers on Lisp’s explicit scoping and binding constructs (e.g., `let` vs. `let*`), with some seeing them as powerful for reasoning and metaprogramming and others viewing them as historical baggage that hinders adoption. Alongside tooling and language design, participants celebrate older Lisp and programming books and even classic Lisp machine environments like Medley as uniquely coherent, self-contained ways to explore symbolic computation.

Common Lisp REPL and Iterative Workflow

  • Several commenters find CL REPLs awkward compared to IPython, especially for multiline snippets and history editing.
  • Experienced users say the “right” way is not to type into a bare terminal REPL, but to use an editor-integrated REPL (“listener”).
  • In Emacs+SLIME or Vim+Slimv/Vlime, you write code in a buffer and send expressions, regions, or forms to the REPL via keybindings. This gives multiline evaluation and easy re‑evaluation without depending on line-based history.
  • CL REPLs are expression-based, not line-based; for multiple sequential expressions you can wrap them in progn or let so it’s a single form to edit and re-run.
  • Some implementations or add‑ons (CLISP with readline, rlwrap, linedit, Jupyter kernels for CL) give more IPython-like line history, but most focus is on editor integration instead.

Variable Binding, Scope, and let vs let*

  • A long subthread debates why CL uses forms like let/let* instead of “declare variable anywhere” syntax like var x = y.
  • Defenders argue explicit scoping is a feature: bindings are localized, easier to reason about, and friendlier to macros and metaprogramming. let parallels lambda parameter binding; let* expresses sequential dependencies.
  • Critics find the distinction confusing and non-idiomatic compared to C‑style languages or Schemes that allow define within blocks, claiming it forces extra nesting and hurts readability.
  • Others note many non-C languages historically also required declarations at the top of scopes; appeals to “what most languages do now” are challenged.
  • Various macros (nest, block-like macros that rewrite var into nested lets, TXR Lisp constructs) are mentioned as ways to get alternative syntactic styles without changing the core language.
  • Historical context: let arose later as sugar over lambda; let* later still, and naming is largely legacy rather than a fresh redesign.

Books, Documentation Style, and Learning Lisp

  • Commenters praise older technical books (including Lisp and AWK texts) for being self-contained, linearly organized, and not assuming constant web lookup.
  • Many enjoy reading out-of-date manuals and language books for their perspective, style, and “snapshot in time” feel.
  • Specific Lisp learning paths mentioned include beginner-friendly intros and AI-focused Common Lisp books.
  • Some contrast older, stable platforms (DOS, early Windows, classic Lisp systems) with modern, web-only, fragmented documentation that is harder to navigate linearly.

Lisp Machines, Medley, and Related Systems

  • Some enjoy Medley/Interlisp as a self-contained Lisp-machine-style environment, though others prefer modern CL implementations plus Emacs or commercial IDEs.
  • Mathematica is noted as having a somewhat Lisp-like feel and an enormous built-in library, but its goals and implementation differ from Lisp-machine systems.