Why I Chose Common Lisp

Original Article ↗ Hacker News Discussion ↗

Clojure, Babashka, and GraalVM native-image

  • Several comments focus on Clojure’s native-image story.
  • One camp says GraalVM native-image for Clojure is “solved” if you use specific tooling (e.g., clj-easy/graal-build-time) and follow known patterns, though this “mostly works” for pure Clojure and needs manual tweaks for reflection, native libs, and build-/run-time init.
  • Others argue this is overstated: retrofitting existing, complex Clojure apps is described as “next to impossible,” with opaque errors and subtle runtime misbehavior.
  • Babashka is praised for fast-start CLI tools, but it doesn’t meet strict standalone-binary requirements for arbitrary codebases.

Common Lisp executables and delivery

  • Common Lisp implementations (notably SBCL) are said to make native executables straightforward: save an image that already contains compiled code, tools, and data.
  • “Delivery” is highlighted as a distinct discipline: shrinking images, stripping debug info, tuning GC, embedding into shared libraries, and building platform-specific bundles.
  • CL is praised for interactive patching of deployed binaries via REPL, even without the original source, though commenters also stress the need for version control and backups.

Editors and tooling (Vim, Emacs, VS Code)

  • Many describe productive workflows with Vim + vim-slime (or slimv) and tmux, treating Vim + REPL as a lightweight IDE.
  • Others argue Emacs + SLIME/SWANK (or similar) remains the gold standard for Lisp, due to deep integration with the running image and rich ecosystem (org-mode, Magit, structural editing).
  • There’s a long subthread debating Vim/Emacs vs GUI IDEs and VS Code:
    • Some say Vim/Emacs are outdated and VS Code’s extension ecosystem “won”;
    • Others counter that VS Code is bloated, telemetry-heavy, has weak CL support, and a risky extension ecosystem, while Emacs/Vim remain powerful, customizable “power tools.”

Alternative languages and Lisps

  • Other candidates mentioned: Janet, Gerbil Scheme, Chicken Scheme, Jank, F#, Julia, Racket, Go, Rust, Zig.
  • Janet and Gerbil get positive notes for small/fully static binaries.
  • Julia is discussed at length: strong numerics, good C/Python FFI, improving but still-painful compile times, weaker networking and multithreading integration with C, and mixed experiences vs CL.
  • Scheme/Racket are viewed as powerful but hampered by standard/library fragmentation and a smaller, more academic ecosystem.

Community and learning resources

  • CL communities exist on Discord, but several prefer open, persistent venues like IRC (#commonlisp, #lispcafe on Libera) and even Usenet.
  • Suggested learning paths include the Common Lisp HyperSpec, “Practical Common Lisp,” “Gentle Introduction to Symbolic Computation,” Steve Losh’s “A Road to Common Lisp,” and “batteries-included” images like CIEL.