An Exploration of SBCL Internals (2020)

Original Article ↗ Hacker News Discussion ↗

Popularity and Language History

  • Several comments lament that Common Lisp/SBCL is niche despite powerful features.
  • Explanations offered:
    • In the 80s–90s Lisp and Smalltalk were expensive, memory-hungry, and often slower; C/C++ were cheaper and leaner.
    • Java and C++ leveraged C’s installed base, familiar syntax, free or cheap tools, and large-team suitability.
    • Java’s “C-like” surface was enough for quick adoption, even though its semantics differ from C++.
  • Some argue Lisp doesn’t scale well with inexperienced developers and isn’t “zero cost” due to GC and (sometimes) interpretation; others say scalability concerns are overstated and praise Common Lisp’s ergonomics and composition.

Tooling, Emacs, and Onboarding Friction

  • A recurring hurdle: perception that one must learn Emacs + SLIME to use SBCL.
  • Alternatives cited: Vim/neovim plugins, Geany plugin, Lem editor, Portacle bundle, Pulsar/Atom, Sublime, Eclipse, VSCode, Jupyter-style setups.
  • Some see Emacs as a worthwhile “cult” with big payoffs (Org, Magit, deep integration); others are turned off by editor learning curves and just want a quick “hello world” like Python/IDLE or JS/VSCode.
  • Comparisons note that trying Python took minutes, whereas getting a working CL environment (e.g., Lem on macOS) can fail or be painful.

Compilation, Evaluation, and Performance

  • Multiple posts stress that serious CL implementations compile code; SBCL and CCL often compile even REPL input.
  • SBCL has multiple evaluators; defaults favor compilation. CMUCL history and interpreter removal/return are discussed.
  • Other CLs like ABCL and ECL compile to JVM bytecode or C; GCL/clisp’s C-based approach is seen as producing weaker code.
  • A cited book and older functional-language compilers are praised for sophisticated optimizations leveraging purity and uniform data representations.

Image-Based REPL Development

  • One participant attributes a profitable SBCL-based startup’s success to REPL/image-based development: patching a running system, fast debugging, and incremental evolution.
  • Comparisons are made to Smalltalk and Factor images, and to Jupyter notebooks as a weaker analogue.
  • Question is raised about how live image updates interact with real production state (sessions, handlers) today; the thread does not offer concrete modern practices, so this remains unclear.

Implementations, Ecosystem, and Free Software

  • Discussion of commercial vs free CLs: earlier cost likely hurt adoption; now Allegro and LispWorks remain, with modest but ongoing releases and patch workflows.
  • SBCL is praised for documentation and frequent releases; this reportedly helped quick Apple Silicon support.
  • Clozure CL’s backend is described as under-documented “institutional knowledge”; Apple Silicon support has lagged, though recent news indicates renewed, partially funded ARM64 work.
  • Free-software roots of GNU tools are tied back to frustrations with proprietary Lisp systems; GNU CL variants existed but were technically and resource constrained.

Technical Corrections and Miscellany

  • Readers correct the article on x86 being little-endian and on confusing bits vs bytes in a lowtag explanation.
  • SBCL’s name is clarified as a play on its CMU heritage (steel and banking industries).