ANSI Common LISP (Paul Graham) (Z-Library)

【One-Line Pitch】 A dual-purpose introduction and reference for ANSI Common Lisp, this book teaches the language from first principles while diving deep into advanced topics like CLOS, macros, and optimization—ideal for beginners who want a solid foundation and professionals seeking a practical handbook. 【Book Arc】 - **Opening (~0%–10%)**: Introduces Lisp's core philosophy—prefix syntax, code-as-data, and dynamic allocation—establishing the mental model needed for everything that follows. - **Early (~10%–30%)**: Covers fundamental programming constructs: recursion, functional programming, types, and implicit pointers, with exercises that build fluency in thinking in Lisp. - **Middle (~30%–60%)**: Explores closures, macros, and the power of bottom-up programming, showing how to extend the language itself rather than just write programs in it. - **Late (~60%–85%)**: Delves into the Common Lisp Object System (CLOS), including class precedence and generic functions versus message-passing, plus a guide to writing your own object-oriented language. - **Ending (~85%–100%)**: Provides a complete optimization guide and an appendix on debugging common errors, rounding out the book with practical, production-oriented advice. 【Key Takeaways】 - **Prefix syntax and code-as-data are the foundation** (Early): Understanding that Lisp code is itself Lisp data unlocks the language's metaprogramming power—this is the single most important conceptual shift for new learners. - **Recursion replaces iteration as the default thinking tool** (Early): The book trains you to decompose problems recursively, a skill that transfers to any language and sharpens algorithmic thinking. - **Closures are the bridge between data and behavior** (Middle): By capturing lexical environments, closures enable elegant state management and higher-order programming patterns that are hard to replicate in other languages. - **Macros are the ultimate language extension mechanism** (Middle): The book's macro treatment is exceptionally clear, showing how to write code that writes code—essential for bottom-up programming and embedded domain-specific languages. - **CLOS offers a different object model than message-passing** (Late): Generic functions dispatch on all arguments, not just the receiver, which changes how you design polymorphic systems and is a key insight for OOP practitioners. - **Optimization is a systematic process, not guesswork** (Ending): The guide covers profiling, type declarations, and compiler hints, teaching you to make Lisp fast without sacrificing its expressive power. - **Rapid prototyping and bottom-up design are complementary styles** (Late): The examples demonstrate how building small, reusable pieces upward leads to more maintainable and flexible systems than top-down decomposition alone. 【Reading Tips】 - **Skim the reference sections** (throughout): The book doubles as an ANSI reference; don't read those parts linearly—consult them when you need a specific function or syntax detail. - **Deep-read the macro chapters** (Middle): This is the book's standout content; work through every example by hand, expanding macros mentally or on paper to truly internalize how they transform code. - **Do the exercises in the early chapters** (Early): Recursion and functional programming only click with practice; the problems are designed to build muscle memory for Lisp thinking. - **Treat the CLOS section as a design discussion** (Late): Don't just learn the syntax—compare generic functions to message-passing in your own projects to understand when each model shines. - **Use the optimization guide as a checklist** (Ending): When your Lisp code runs slow, return to this section and apply its profiling and declaration techniques systematically rather than guessing. 【Coverage Limits】 The excerpts primarily capture the book's front matter and back matter; the detailed chapter-by-chapter content is not fully represented in the source material, so specific examples and exact chapter structures are inferred from the blurb's descriptions.