A Road to Lisp: Which Lisp

Original Article ↗ Hacker News Discussion ↗

Choosing “which Lisp” to learn or use quickly opens broader questions about language design, tooling, and how people actually like to think about programs. Commenters compare Common Lisp, Scheme/Racket, Clojure and others on readability, dynamic vs static typing, performance, macro power, and ecosystem maturity, with many noting Lisp’s strengths in extensibility and live, REPL-driven workflows but also its hurdles in editor support and long-term maintainability. The thread highlights a recurring theme: the best Lisp often depends less on abstract elegance and more on available tooling, host platform, and whether you value stability, job relevance, or experimentation.

Choosing a Lisp dialect

  • Several recommend “just pick one and start,” with Common Lisp and Scheme as the main options.
  • Scheme is praised for its small, clean core (good for learning, SICP, TSPL, Racket/DrRacket, Guile, Chez, Chicken, Gambit/Gerbil).
  • Common Lisp is highlighted for its stable, complete spec, performance (e.g., SBCL), portability of decades-old code, and extensive standard library.
  • Clojure is recommended for practical work, JVM/host ecosystem, low library churn, EDN, and tools like Babashka.
  • Other dialects mentioned: Emacs Lisp, AutoLISP, Racket, Guile, Janet, Fennel, Jank, Jolt, Rhombus, Hylang, Gerbil, and bare-metal Lisps.

Readability, syntax, and style

  • Some find Lisp hard to read and never fully “natural,” especially compared to more conventional procedural syntax.
  • Others claim a tipping point where Lisp becomes more readable than other languages once you mentally ignore parentheses and rely on indentation and structural editing.
  • Common Lisp can be written in a very procedural style; loops/macros (“loop”, “dotimes”, etc.) make it feel familiar to Algol-like languages.
  • Alternative syntaxes (e.g., Rhombus, Clojure-style literals in CL, Hiccup-like data markup) are suggested for people who dislike s-expressions.

Macros, extensibility, and “liveness”

  • Common Lisp’s macro system and reader macros are emphasized as enabling arbitrarily extensible syntax, DSLs, and even new languages (e.g., Coalton, JSON literals).
  • Some argue Lisp macros are overhyped; many macro examples can be done with compiler techniques in other languages, and excessively clever macros can hurt maintainability.
  • Others counter that having the full language available at macro-expansion time, plus runtime compilation, remains uniquely powerful and pragmatic.
  • CL and Clojure’s “live image” development (editing a running system) is contrasted with Racket’s more batch-compiled feel.

Specs, typing, and portability

  • ANSI Common Lisp’s frozen spec is both praised (stability, longevity) and criticized (threads, sockets, Unicode, streams, extensible sequences left to non-portable extensions; CLOS not fully integrated).
  • CL supports optional typing and some gradual typing, but critics say it’s “not very well typed” (e.g., coarse list types, no generics).
  • Scheme’s R6RS vs. R7RS situation and OS-interop portability problems are noted as another source of fragmentation.
  • One participant struggles with dynamic languages in general, missing static guarantees about program soundness; proposed mitigations (tests, REPL, live editing) feel insufficient, and the “right” workflow remains unclear.

Tooling and learning resources

  • Emacs remains the canonical experience for many; others actively dislike it and seek alternatives.
  • Suggested tools: LispWorks (powerful but expensive for hobbyists), Mine and Lem (new CL IDEs), OLIVE plugin for VS Code, good Neovim/VS Code setups for Clojure.
  • Recommended learning paths: “Practical Common Lisp,” “An Introduction to Programming in Emacs Lisp,” SICP, HTDP (Racket), “The Scheme Programming Language,” Haskell resources for FP concepts.

Meta-perspectives

  • Some argue Lisp isn’t as uniquely magical as its reputation suggests; many ideas exist elsewhere.
  • Others insist that the specific combination of homoiconicity, macros, REPL-driven development, and host interop across many runtimes makes Lisp unusually effective and “all roads lead to Lisp” over a long career.