Learning Common Lisp

A Complete Guide to Common Lisp Programming from First Principles to Advanced Metaprogramming

Introduction: Why Lisp Still Matters

1. What You Will Learn
2. How to Use This Book
3. The Lisp Mindset

Chapter 1: The Lisp Way of Thinking

1. A Language That Thought Differently
2. Code as Data: The Fundamental Insight
3. Installing Your First Lisp Environment
4. Reading Your First S-Expression
5. Interactive Development: The REPL as Your Laboratory

Chapter 2: Core Syntax and Data Structures

1. Atoms, Symbols and Literals
2. Lists: The Foundation of Everything
3. Vectors, Arrays and Hash Tables
4. Strings and Characters
5. Type System Overview

Chapter 3: Functions and Control Flow

1. Defining Functions with DEFUN
2. Lambda Expressions and Anonymous Functions
3. Conditionals: IF, COND and, OR, WHEN, UNLESS
4. Loops: The LOOP Macro and Alternatives
5. Multiple Values

Chapter 4: Recursion and Higher-Order Programming

1. Recursive Thinking: From Iteration to Recursion
2. MAPCAR, REDUCE and Functional Higher-Order Tools
3. Closures: Functions That Remember
4. Tail Call Optimization and Efficient Recursion
5. Building Your Own Higher-Order Utilities

Chapter 5: Lexical Scope and the Environment Model

1. Lexical Binding and LET Forms
2. Dynamic Binding and Special Variables
3. Parameter Passing: Required, Optional, Rest and Keyword Arguments
4. The Environment Model: How Lisp Resolves Names
5. Common Scoping Pitfalls and How to Avoid Them

Chapter 6: Macros and Metaprogramming

1. Why Macros Exist: The Limits of Functions
2. Your First Macro: DEFMACRO Explained Step by Step
3. Pattern Matching and Template Writing
4. Hygienic Concerns and Variable Capture
5. Real-World Macros: DSLs, Domain-Specific Languages
6. Advanced Metaprogramming: Compile-Time Computation

Chapter 7: The Common Lisp Object System (CLOS)

1. Classes and Instances: DEFCLASS and Slot Definitions
2. Generic Functions and Multiple Dispatch
3. Method Combination: Beyond Simple Inheritance
4. The Metaobject Protocol: Programming the Object System
5. Practical OOP in Lisp: When to Use CLOS

Chapter 8: Error Handling and the Condition System

1. Conditions vs Exceptions: A Different Model
2. Signaling Errors and Warnings
3. Handlers and Restart Functions
4. Defining Custom Conditions and Restarts
5. Interactive Debugging with the Condition System

Chapter 9: Packages and Modular Programming

1. The Package System: Namespaces Done Right
2. Exporting and Importing: Controlling Visibility
3. Project Structure for Real Applications
4. Build Systems: ASDF and Quicklisp
5. Testing Frameworks: FiveAM and Test Driven Development

Chapter 10: Performance and Optimization

1. Understanding SBCL’s Compilation Model
2. Type Declarations: Telling the Compiler What You Know
3. Profiling and Measuring Performance
4. Memory Management and Garbage Collection
5. When to Optimize: Premature Optimization in a Dynamic Language

Chapter 11: Concurrency and Parallelism

1. Threads in Common Lisp
2. Synchronization Primitives
3. Shared State and Race Conditions
4. Message Passing and Actor-Like Patterns
5. Parallel Computation: Dividing Work Across Cores

Chapter 12: Building Real Applications

1. Web Development with Lisp
2. Database Access and Persistence
3. Interoperability: Calling C, FFI and Foreign Libraries
4. Command-Line Tools and Daemons
5. Modern Development Workflows

Conclusion: The Future of Lisp Thinking

1. What You Have Learned
2. Lisp’s Influence on Modern Programming
3. Why Lisp Remains Relevant
4. Career Considerations
5. The Lisp Community
6. Continuing Your Journey
7. Final Thoughts

References