Why I Program in Lisp

Original Article ↗ Hacker News Discussion ↗

Lambda expressions and “properly working” functions

  • Commenters dispute the claim that only Lisp had “properly working lambda expressions until recently,” noting Haskell/ML had them for decades.
  • Some suggest “properly” refers less to bare lambdas and more to a coherent design of scope, extent, and compile-time vs run-time (e.g., EVAL-WHEN), but they clarify this is not an attack on Haskell/ML.

Wording and clarity

  • Several comments dissect the ambiguous phrase “only available in Lisp until recently” and propose clearer variants (“were available only in Lisp until recently” / “Until recently, …”).
  • Discussion highlights the importance of precise English in technical writing.

Why Lisp feels compelling & how people learn it

  • Readers report the article making them want to learn Lisp; suggestions include Common Lisp (LispWorks, PAIP, On Lisp), Clojure, and classic talks and videos.
  • Common motivations: expressiveness, powerful macros, refactoring ease, interactive REPL, “joyful” feeling, and CLOS/MOP.

Language power vs equivalence

  • Debate over the aside that “other general-purpose languages can do everything Lisp can (if Church/Turing are correct).”
  • Some argue Turing completeness doesn’t capture ergonomics; implementing Lisp in another language is not the same as that language being as usable for Lisp-like abstractions.
  • Turing tarpit examples (Brainfuck) are cited to separate theoretical power from practical suitability.

Functional programming, purity, and I/O

  • Long subthread on whether “purely functional” is practical given most real programs are I/O-heavy.
  • Consensus: pure FP doesn’t eliminate side effects but isolates them (functional core, imperative shell; IO monads, effect systems).
  • Several examples show separating “world” (I/O, state) from “model” (pure transformations) and how this aids testing, reasoning, and error handling.
  • Haskell’s IO, logging patterns (Writer monads, laziness), and challenges with randomness and effects are discussed, alongside more pragmatic FP in languages like Clojure, F#, and Erlang.

Closures, first-class functions, and state

  • Clarifications that C function pointers aren’t first-class functions (no lexical capture).
  • Many describe closures as transformative for design, emphasizing that GC and lexical scope make them practical and safe.
  • Historical notes: early languages (Algol) already had nested procedures and partial closure-like behavior.

Lisp vs other dynamic languages (Ruby, Python, JS)

  • Some see the article’s arguments as also favoring Ruby (dynamic, expressive, ad-hoc polymorphism), but Lisp is cited as having stronger compilation, macros, and optimization hooks (the).
  • Others argue JS/Python have adopted many “Lisp” features, but that Common Lisp still offers more raw metaprogramming power.

Syntax, parentheses, and reading order

  • Persistent thread on parentheses anxiety and “inside-out” reading; proponents say this fades quickly with experience and structural editors.
  • Comparisons to infix, method-chaining, and arrow macros (->) suggest much of the perceived right-to-left-ness exists in other languages too.
  • Some suggest that Lisp’s AST-like surface syntax is both its strength (easy macros, homoiconicity) and a conceptual shift.

Tooling, environments, and ecosystem

  • Several note modern Lisp environments lag behind classic Lisp machines and mainstream IDEs.
  • Others counter that Common Lisp tooling (SLIME/Sly, various editor integrations) plus interactive debugging and image-based development rival or exceed Python-like workflows, though advanced refactoring is weaker.
  • Binary size, tree-shaking (LispWorks vs SBCL/ECL), and library gaps are acknowledged tradeoffs.

Adoption, production use, and culture

  • Question raised why Lisp remains rare in production: answers cite ecosystem, hiring pool, and lack of strong, modern, integrated environments.
  • Some point to successful but niche Lisp systems (CL-based apps, embedded Lisps, scripting in CAD tools).
  • There is light meta-commentary: Lisp (and Haskell) are sometimes used partially for intellectual pleasure and blog-worthiness; nonetheless many participants emphasize genuine productivity and maintainability benefits.