Common Lisp Guide: Master Modern Symbolic Programming

Why Learn Common Lisp Today?

Before we dive into syntax, let’s address the elephant in the room: viability. Is Lisp relevant in 2024? Absolutely. While it may not top the TIOBE index, it powers critical systems in aerospace (NASA), high-frequency trading, and sophisticated Artificial Intelligence research. Learning Common Lisp expands your mental model of programming in ways that learning another C-family language cannot.

• Programmable Programming Language: Through its macro system, you can extend the language to suit your problem domain, essentially creating your own Domain Specific Language (DSL).
• The REPL Experience: Development in Lisp is conversational. You don’t “write-compile-run.” You interact with a living image of your program, modifying functions while the system is running.
• Maturity: Common Lisp is a standardized language (ANSI). Code written 30 years ago still runs today on modern compilers like SBCL (Steel Bank Common Lisp).

Setting Up Your Lisp Environment

To follow this guide, you need a working Lisp environment. We will use SBCL as our compiler and Quicklisp as our package manager.

Step 1: Install SBCL

On macOS (using Homebrew):

brew install sbcl

On Ubuntu/Debian:

sudo apt-get install sbcl

Step 2: Install Quicklisp

Quicklisp is the “npm” or “pip” of the Lisp world. Download the installer script:

curl -O https://beta.quicklisp.org/quicklisp.lisp
sbcl --load quicklisp.lisp

Inside the SBCL prompt, run:

;; Install Quicklisp to your home directory
(quicklisp-quickstart:install)

;; Add it to your init file so it loads every time you start SBCL
(ql:add-to-init-file)

Step 3: Choose an Editor

While you can use Vim or VS Code (with the “Alive” extension), the gold standard is Emacs with SLIME (Superior Lisp Interaction Mode for Emacs). For beginners, Portacle is a portable, pre-configured Emacs distribution that works out of the box.

The Core Philosophy: S-Expressions

In Lisp, everything is an S-expression (Symbolic Expression). An S-expression is either an atom or a list. This uniformity is what gives Lisp its power.

Prefix Notation

Unlike languages that use infix notation (e.g., 1 + 2), Lisp uses prefix notation. The function (or operator) always comes first inside the parentheses.

;; Instead of 1 + 2 + 3
(+ 1 2 3) ;; Returns 6

;; Instead of print("Hello World")
(format t "Hello World")

This might look strange at first, but it eliminates operator precedence ambiguity. You never have to worry about whether multiplication happens before addition; the parentheses make the execution order explicit.

Understanding Variables and Data Types

Lisp is dynamically typed, but it is also strongly typed. A variable doesn’t have a fixed type, but the value it holds does.

Defining Variables

We use defparameter for global variables that might change and defvar for ones that should only be initialized once.

;; Global variable
(defparameter *pi-estimate* 3.14159)

;; Local variable using 'let'
(let ((x 10)
      (y 20))
  (+ x y)) ;; Returns 30. x and y are not accessible outside this block.

The List: The Heart of Lisp

A list is created by surrounding elements with parentheses. However, because Lisp tries to evaluate every list as a function call, we must “quote” a list if we want to treat it as data.

;; This would throw an error because 1 is not a function
;; (1 2 3) 

;; Use the quote ' symbol to treat it as a literal list
'(1 2 3) ;; Returns the list (1 2 3)

;; You can also use the 'list' function
(list 1 2 3) ;; Returns (1 2 3)

Functions: The Building Blocks

Functions in Common Lisp are defined using the defun macro. The structure is (defun name (arguments) body).

;; A simple function to square a number
(defun square (n)
  "Calculates the square of the number n."
  (* n n))

;; Calling the function
(square 5) ;; Returns 25

;; A function with multiple arguments
(defun average (a b)
  (/ (+ a b) 2.0))

(average 10 20) ;; Returns 15.0

Optional and Keyword Arguments

Common Lisp offers incredible flexibility in how functions receive data.

(defun greet (name &key (greeting "Hello") (suffix "!"))
  (format t "~A, ~A~A" greeting name suffix))

;; Calling with keywords
(greet "Alice" :greeting "Welcome" :suffix "...") 
;; Outputs: Welcome, Alice...

The Power of Symbolic Computation

This is where Lisp diverges from most languages. Because code and data share the same representation (lists), Lisp can manipulate its own source code as easily as it manipulates a list of integers.

Imagine you want to write a program that differentiates mathematical equations. In C++, you’d need a complex parser. In Lisp, the equation (+ (* x x) 1) is already a data structure (a list of symbols and numbers) that you can traverse recursively.

;; A tiny example of inspecting code as data
(defparameter *my-code* '(+ 1 2))

;; We can look at the "function name"
(first *my-code*) ;; Returns the symbol +

;; We can evaluate it manually
(eval *my-code*) ;; Returns 3

Warning: Use eval sparingly. Usually, there’s a better way to do things using macros.

Control Flow and Recursion

Lisp provides standard branching via if, when, and cond.

;; Basic IF: (if condition then-clause else-clause)
(if (> 10 5)
    "Ten is greater"
    "Something is wrong")

;; COND: The Lisp "Switch" statement
(defun categorize-age (age)
  (cond ((< age 13) "Child")
        ((< age 20) "Teenager")
        ((< age 65) "Adult")
        (t "Senior"))) ;; 't' acts as the default 'else'

Recursion

Lisp programmers often prefer recursion over iterative loops. Here is the classic factorial example:

(defun factorial (n)
  (if (<= n 1)
      1
      (* n (factorial (- n 1)))))

(factorial 5) ;; Returns 120

Modern Lisp compilers like SBCL perform Tail Call Optimization (TCO), meaning you can write recursive functions without worrying about blowing the stack, provided the recursive call is in the “tail” position.

Macros: The “Code that Writes Code” Feature

Macros are the most famous (and feared) feature of Lisp. While a function takes values as input and returns a value, a macro takes code as input and returns new code that is then compiled.

Suppose you want a backwards command that executes code in reverse order. You can’t do this with a function because the arguments would be evaluated before the function even runs. But with a macro, you can.

(defmacro backwards (expr)
  (reverse expr))

;; Usage:
(backwards (10 20 +)) ;; This expands to (+ 20 10) at compile time!
;; Returns 30

This allows you to create features that the language designers never thought of. Do you want a while loop (which Common Lisp has, but for example’s sake)? You can write a macro that transforms a while syntax into a series of jumps or recursive calls.

The Condition System: Better than Exceptions

Most languages use Try/Catch blocks. When an error occurs, the stack is unwound, and you lose the context of the error. Common Lisp uses a Condition System with Restarts.

In Lisp, when an error occurs, you can handle it without unwinding the stack. You can fix the problem and continue execution from where the error happened.

(define-condition high-temperature-error (error)
  ((temp :initarg :temp :reader temp)))

(defun monitor-reactor (temp)
  (if (> temp 100)
      (restart-case (error 'high-temperature-error :temp temp)
        (cool-down () 
          :report "Lower the temperature"
          (monitor-reactor 80))
        (ignore-danger () 
          :report "Do nothing and hope for the best"
          nil))
      (format t "Reactor safe at ~A degrees." temp)))

When this code fails, the user or a parent function can choose cool-down or ignore-danger interactively or programmatically. This is why Lisp systems can be debugged and fixed while they are running in production.

Common Mistakes and How to Fix Them

1. Forgetting to Quote Lists

The Mistake: Typing (1 2 3) in the REPL.

The Result: Error: 1 is not a function.

The Fix: Use '(1 2 3) when you mean the data structure, not an execution.

2. Misunderstanding Global Variables

The Mistake: Using setf on a variable that hasn’t been defined.

The Fix: Always use defparameter or defvar first to declare a global variable. Use setf only to update its value.

3. Parentheses Mismatch

The Mistake: Losing track of closing parentheses )))).

The Fix: Never count parentheses. Use an editor with Paredit or Rainbow Parentheses. The editor should handle the closing brackets for you.

4. Naming Conflicts

The Mistake: Naming a function list or sum which might conflict with built-ins.

The Fix: Use descriptive names or organize code into packages (Lisp’s version of namespaces).

Step-by-Step: Building a Simple Mini-App

Let’s build a basic “To-Do List” manager to see how all these pieces fit together.

1. Define the Global State

(defvar *todo-list* nil)

2. Create a Function to Add Items

(defun add-task (task)
  (push task *todo-list*)
  (format t "Added: ~A~%" task))

3. Create a Function to Show Items

(defun show-tasks ()
  (if (null *todo-list*)
      (format t "Your list is empty!~%")
      (dolist (task (reverse *todo-list*))
        (format t "- ~A~%" task))))

4. Use it in the REPL

CL-USER> (add-task "Buy milk")
Added: Buy milk
CL-USER> (add-task "Learn Lisp Macros")
Added: Learn Lisp Macros
CL-USER> (show-tasks)
- Buy milk
- Learn Lisp Macros