Lisp from Nothing, Second Edition

Lisp syntax, parentheses, and alternatives

• Several comments discuss discomfort with traditional S-expressions and experiments to make Lisp look less alien (e.g., alternative tuple notations, reducing visible parentheses).
• Others argue parentheses are a feature: they enable powerful structural editing and code-as-data manipulation; attempts to “fix” the syntax (M-expressions, Dylan, “sweet expressions”) never really stuck.
• Racket and Clojure are highlighted as good compromises: using different brackets for different structures (vectors, maps, bindings) improves visual parsing and reduces clutter.
• Debate around R6RS making [ interchangeable with (: some like the visual help; others feel it wastes the chance to give [] a distinct meaning (e.g., vectors).
• Removing parentheses from let/cond pairs is seen by some as reducing noise, by others as harming structural editing and clarity with multi-form clauses.

Functional style, data structures, and evaluation

• One subthread contrasts deeply nested function calls with step-by-step imperative style and pipeline/arrow notation; people note that comfort is mostly a matter of habit.
• Another subthread discusses applicative (functional) vs imperative styles: lists are great for functional updates but weaker for indexing, appending, and map lookups, pushing many Lisps toward vectors/hash tables.
• Clojure’s HAMT-based structures are credited with making purely applicative code more practical.
• There is a short critique of the Church-encoded list implementation in the book’s church.scm, suggesting a more compact representation with fewer booleans.

Lambda calculus vs Lisp, and metacircular evaluators

• One comment clarifies: lambda calculus corresponds to Lisp’s lexical lambda without explicit environments; environments are an implementation detail to avoid textual substitution.
• Metacircular evaluators are defended as central because they vividly demonstrate “code as data,” and give a compact, almost axiomatic description of a language, likened to Maxwell’s equations for electromagnetism.
• There is interest in whether an even more compact, unified representation of eval is possible; an example from binary lambda calculus is mentioned as a very terse self-interpreter.

Author, book scope, and related works

• Multiple readers praise the author’s previous books (especially Scheme 9 from Empty Space and Practical Compiler Construction) for clarity, brevity, and beauty, treating them as almost poetic “lifetime projects” rather than purely practical manuals.
• The author confirms this: motivation is to create something personally beautiful and to transmit knowledge in a digestible way; also comments on a simple, modest lifestyle influenced by contemplative practice.
• The title “Lisp from Nothing” is clarified as “from scratch / from a minimal base,” not a beginner intro. It focuses on bootstrapping early Lisp rather than teaching Lisp from zero.
• For newcomers, commenters recommend other Lisp/Scheme introductions first: ANSI Common Lisp, How to Design Programs, The Little Schemer series, A Gentle Introduction to Symbolic Computation, Successful Lisp, plus classic papers like “Roots of Lisp.”

Usefulness, minimalism, and standard libraries

• One critic questions the point of yet another minimal language without a standard library or syscall interface.
• Others respond that the goal here is not application-level usefulness but understanding the essence of computation and language implementation—more like art or conceptual exploration than product engineering.

Miscellaneous reactions

• Several people immediately purchase the new edition and other books after browsing the site; the bibliography and essays (especially on philosophy and “who am I?”) are described as delightful.
• The “no AI” badge on the back cover is noted as ironic given Lisp’s historical link to AI; commenters interpret it as “no generative AI used,” sometimes joking that no AI was harmed—or harming the planet—in making the book.