9 of the Best Free Lisp Books

1. COMMON LISP: An Interactive Approach

COMMON LISP: An Interactive Approach is a self-paced study guide to teach readers the COMMON LISP programming language. It aims to help programmers learn this dialect by experimenting with it via an interactive computer terminal.

This book has been used as the text of the Lisp portion of data structures, programming languages, and artificial intelligence courses and as a self-study guide for students, faculty members, and others learning Lisp independently.

This book examines the following areas:

The Basics:

• Numbers - interact with the Lisp listener and distinguishing between objects and their printed representations
• Lists - discusses the most important type of Lisp object, the list
• Arithmetic - start evaluating list objects. Evaluating list objects is the basic operation involved in writing, testing, and using Lisp
• Strings and Characters - along with lists, symbols are the most important kind of objects in Lisp because they are used for program variables, for function names (as was already briefly mentioned), and as data to allow Lisp programs to manipulate symbolic data as well as numeric data
• Symbols - another Common Lisp data type, like integers, floating-point numbers, ratios, characters, strings, and lists
• Packages - the symbols a programmer intends others to use can be exported from its original package (called its home package) and imported into another package
• Basic List Processing - discusses the use of lists as data objects—that is, list processing—what Lisp was named for

Programming in Pure Lisp

• Defining your Own Functions - examines the special form defun
• Defining Functions in Packages
• Saving for Another Day
• Predicate Functions - functions that return either True, represented by Lisp as T, or False, represented by Lisp as NIL
• Conditional Expressions - one of the two most powerful features of any programming language is the conditional
• Recursion - the use of recursive functions is called recursion
• Recursion on Lists, Part 1 - Analysis: start writing recursive functions that operate on lists
• Recursion on Lists, Part 2 - Synthesis
• Recursion on Trees
• The Evaluator - Lisp’s evaluator is the function eval, a function of one argument. It gets its single argument evaluated, and it evaluates it one more time and returns that value
• Functions with Arbitrary Numbers of Arguments - consider the entire structure of lists whose members are also lists and allow recursion down the first parts as well
• Mapping Functions
• The Applicator
• Macros - another kind of functionlike object that get their arguments unevaluated

Programming in Imperative Lisp:

• Assignment - the most basic imperative statement is the assignment statement, which assigns a value to a variable
• Scope and Extent - the scope of a variable is the spatiotemporal area of a program in which a given variable has a given name. The extent of a variable is the spatiotemporal area of a program in which a given variable has a given storage location
• Sequences
• Local Variables - introduce one or more new local, lexically scoped variables that will be used only within the body of a single function
• Iteration - the traditional imperative way of repeating computations, and iterative constructs have been included in Common Lisp for those programmers who prefer them
• Input/Output
• Destructive List Manipulation
• Property Lists - the use of property lists to store information about symbols or about the entities the symbols represent
• Hash Tables - a type of Common Lisp object that are used for associating arbitrary pieces of information with each of a set of Common Lisp objects

Object-Oriented Programming:

• Methods
• Classes

2. Practical Common Lisp

Practical Common Lisp presents a thorough introduction to Common Lisp, providing readers with an overall understanding of the language features and how they work. 

Over a third of the book is devoted to practical examples such as the core of a spam filter and a web application for browsing MP3s and streaming them via the Shoutcast protocol to any standard MP3 client software (e.g., iTunes, XMMS, or WinAmp). 

In other "practical" chapters, author Peter Seibel demonstrates how to build a simple but flexible in-memory database, how to parse binary files, and how to build a unit test framework in 26 lines of code.

3. Common Lisp: A Gentle Introduction to Symbolic Computation

Common Lisp: A Gentle Introduction to Symbolic Computation is about learning to program in Lisp. Although widely known as the principal language of artificial intelligence research—one of the most advanced areas of computer science—Lisp is an excellent language for beginners.

The book is aimed at:

• Students taking their first programming course
• Psychologists, linguists, computer scientists, and other persons interested in Artificial Intelligence
• Computer hobbyists

Chapters cover the following:

• Introduction - begins with an overview of the notions of function and data, followed by examples of several built-in Lisp functions
• Lists - these are the central data type for Lisp
• EVAL notation - a more flexible notation. EVAL notation allows us to write functions that accept other functions as inputs
• Conditionals - study some special decision-making functions, called conditionals, that choose their result from among a set of alternatives based on the value of one or more predicate expressions
• Variables and Side Effects - provides readers with a better understanding of the different kinds of variables that may appear in Lisp programs, how variables are created, and how their values may change over time
• List Data Structures - presents more list-manipulation functions, and shows how lists are used to implement such other data structures as sets, tables, and trees
• Applicative Programming - based on the idea that functions are data, just like symbols and lists are data, so one should be able to pass functions as inputs to other functions, and also return functions as values
• Recursion - Recursive control structure is the main topic of this chapter, but we will also take a look at recursive data structures in the Advanced Topics section
• Input/Output - Lisp’s read-eval-print loop provides a simple kind of i/o, since it reads expressions from the keyboard and prints the results on the display
• Assignment - frequently used in combination with iterative control structures, which are discussed in the following chapter
• Iteration and Block Structure - provides powerful iteration constructs called DO and DO*, as well as simple ones called DOTIMES and DOLIST. Learn about block structure, a concept borrowed from the Algol family of languages, which includes Pascal, Modula, and Ada
• Structures and The Type System - explains how new structure types are defined and how structures may be created and modified. Structures are an example of a programmer-defined datatype
• Arrays, Hash Tables And Property Lists - briefly covers three distinct datatypes: arrays, hash tables, and property lists
• Macros and Compilation - use evaltrace diagrams and a little tool called PPMX (defined in the Lisp Toolkit section) to see how macros work. The chapter also looks at compilation. The compiler translates Lisp programs into machine language programs, which can result in a 10 to 100 times speedup

At the end of each chapter there is optional advanced material to hold interest of junior and senior science majors. There are also exercises for the reader to work through.