# Awesome Common Lisp Learning [![Awesome](https://awesome.re/badge.svg)](https://awesome.re)

<div align="center">
  <img src="LISP_logo_mid.png">
</div>

This list focuses on resources for learning Common Lisp, especially resources that I've found useful.

There are other Awesome Common Lisp lists that focus on other topics:
- [Libraries](https://github.com/CodyReichert/awesome-cl)
  - [Curated Libraries](https://github.com/vindarel/curated-awesome-cl) - Forked and updated from the above list.
- [Software](https://github.com/azzamsa/awesome-cl-software)

Contributions are welcome. Please read the [contribution guidelines](contributing.md) for details.

## Contents

- [How To Use](#how-to-use)
- [Lisp Environments](#lisp-environments)
- [Online References](#online-references)
- [Online Books](#online-books)
- [Offline Books](#offline-books)
- [Online Community](#online-community)
- [Library Management](#library-management)
- [Common Lisp Implementations](#common-lisp-implementations)
- [Credit](#credit)

## How To Use
1. Get a Lisp environment.
2. Bookmark the [The Common Lisp Hyperspec](http://www.lispworks.com/documentation/common-lisp.html).
3. Download and work through a Lisp book of an appropriate level. Type the examples and play with the code. Feel free to switch books and try a different one.
4. Try out [Exercism](https://exercism.org/tracks/common-lisp).
5. If you get stuck, find an online community and [ask smart questions](http://www.catb.org/esr/faqs/smart-questions.html).
6. Learn about [Quicklisp](https://www.quicklisp.org/beta/).
7. At some point, read your Lisp implementation's manual.

## Lisp Environments
You can run a Lisp implementation directly, but an editing environment makes the experience easier.
- Prepackaged environments
  - [Portacle](https://shinmera.github.io/portacle/) - A portable and multiplatform Common Lisp environment. It ships a slightly customized Emacs with SLIME, SBCL (a popular Common Lisp implementation), Quicklisp and Git. No installation needed, so it's a very quick and easy way to get going.
  - [Lispbox](https://common-lisp.net/project/lispbox/) - An IDE (Emacs + SLIME), Common Lisp implementation (Clozure Common Lisp) and library manager (Quicklisp), pre-packaged as archives for Windows, macOS and Linux. Descendant of "Lisp in a Box" [mentioned](http://www.gigamonkeys.com/book/lather-rinse-repeat-a-tour-of-the-repl.html) in Practical Common Lisp.
  - [Lispworks Personal Edition](http://www.lispworks.com/downloads/) - A non-Emacs based IDE for LispWorks Lisp, with some restrictions.
  - [Allegro Common Lisp](https://franz.com/products/allegrocl/) - Has a free [Express Edition](https://franz.com/downloads/clp/survey) IDE, and [training videos on YouTube](https://www.youtube.com/channel/UCN36UrxtyNBJPaG0kmBJNRw).
- For advanced users
  - [Articulate Common Lisp](http://articulate-lisp.com) - A HOWTO for putting together a Lisp environment, and has information on [useful libraries](http://articulate-lisp.com/project/abcs.html) and how to [structure projects](http://articulate-lisp.com/project/new-project.html).
  - If you're an experienced [Emacs](https://www.gnu.org/software/emacs/) user, you can just install [SLIME](https://common-lisp.net/project/slime/) and a [supported Common Lisp implementation](https://common-lisp.net/project/slime/doc/html/Platforms.html#Platforms). See the [SLIME manual](https://common-lisp.net/project/slime/doc/html/) for more details.
  - The Common Lisp Cookbook has more information about [installing an implementation](https://lispcookbook.github.io/cl-cookbook/getting-started.html) using an implementation manager like [Roswell](https://github.com/roswell/roswell/wiki), or on Docker.

## Online References
- [The Common Lisp Hyperspec (CLHS)](http://www.lispworks.com/documentation/common-lisp.html) - *The* language reference document for Common Lisp. Bookmark it now.
  - [Chapter 7](http://www.lispworks.com/documentation/HyperSpec/Body/07_.htm) - Covers the Common Lisp Object System (CLOS).
- [The ANSI Common Lisp Standard Draft](http://cberr.us/tech_writings/notes/common_lisp_standard_draft.html) - The last draft version of the ANSI INCITS 226-1994 (previously ANSI X3.226-1994) standard.
  - The draft is free, the standard isn't.
  - It's pretty much the same as the official standard, and some people prefer it to the CLHS.
- [The Common Lisp Cookbook](http://lispcookbook.github.io/cl-cookbook/) - A list of useful Lisp recipes. Also contains a list of other online sources of CL information.
- [Common Lisp the Language (2nd Edition) by Guy L. Steele](https://www.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html) - A description of the Common Lisp language from just before it was standardized by ANSI. Don't use it as a reference.
  - [Cliki on CLtL2](https://cliki.net/Getting+Started) - Claims it has more useful descriptions of [LOOP](http://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/clm/node235.html#SECTION003000000000000000000) and [FORMAT](http://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/clm/node200.html) than the CLHS does.
  - [Stack Overflow on CLtL2](https://stackoverflow.com/questions/108537/what-are-the-main-differences-between-cltl2-and-ansi-cl) - Some recommend using CLtL2 for insight and inspiration, but to use the CLHS when programming.
  - [A list of differences between CLtL2 and the ANSI Common Lisp specification.](http://linuxfinances.info/info/commonlisp.html#AEN9679)
  - [Chapter 28](https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node260.html#SECTION003200000000000000000) - Covers the Common Lisp Object System.

## Online Books
These books that are freely accessible online, arranged roughly in order from basic to advanced:
- [Common Lisp: A Gentle Introduction to Symbolic Computation by David S. Touretzky](http://www.cs.cmu.edu/~dst/LispBook/) - a good introduction for people new to programming. Contains code for really useful utilities like [DTRACE](http://www.cs.cmu.edu/~dst/Lisp/dtrace/) and [SDRAW](http://www.cs.cmu.edu/~dst/Lisp/sdraw/).
- [Common Lisp: An interactive approach by Stuart C. Shapiro](https://www.cse.buffalo.edu/~shapiro/Commonlisp/) - A textbook that teaches mainly through the use of exercises.
- [Practical Common Lisp by Peter Seibel](http://www.gigamonkeys.com/book/) - A great introduction for experienced programmers, and tries to highlight from the very beginning what makes CL different to other languages.
- [Common Lisp Koans](https://github.com/google/lisp-koans) - Not exactly a book, but a set of koans to help you learn the language.
- [On Lisp by Paul Graham](http://www.paulgraham.com/onlisp.html) - A great book for intermediately experienced Lispers.
- [Let Over Lambda by Doug Hoyte](https://letoverlambda.com) - An advanced book on Lisp Macros.
  - The first six chapters are available online.
  - [Comments on Let Over Lambda](https://www.reddit.com/r/lisp/comments/3actsc/let_over_lambda/) - Several people recommend that you be comfortable with On Lisp before reading this book, and that the start is slow.
  - [The chapter on closures](https://letoverlambda.com/index.cl/guest/chap2.html) - Has several non-trivial examples, and demonstrates the power of this feature.
- [Paradigms of Artificial Intelligence Programming by Peter Norvig](https://github.com/norvig/paip-lisp) - Has many interesting applications of Lisp, but is no longer a good reference for AI.

## Offline Books
These are books that you'll have to buy, or borrow from a library.
- [Land of Lisp by Conrad Barski, MD](http://landoflisp.com) - A fun introduction to Lisp that uses comics and has you writing games.
  - Available as an [ebook](https://www.nostarch.com/lisp.htm). 
  - A couple of the LOOP macros are written `for x for y...` which you can change to `for x from 0 for y...` to make them work in SBCL.
  - Has an [errata page](http://landoflisp.com/errata.html).
  - Most of the book is entertaining and fairly easy, but gets hairy from about Chapter 18. It doesn't feel like later chapters introduce much, so I recommend switching to a different book at that point.
  - The Web server example in Ch 13, 19 and 20 will only work on CLISP, and needs the addition of HTTP response headers to render the HTML properly.
- [ANSI Common Lisp by Paul Graham](http://www.paulgraham.com/acl.html) - Good as a reference, covers CLOS, and has several example program implementations.
  - Plaintext versions of [Chapter 1](http://lib.store.yahoo.net/lib/paulgraham/acl1.txt) and [Chapter 2](http://lib.store.yahoo.net/lib/paulgraham/acl2.txt) are available online.
- [Common Lisp Recipes by Edmund Weitz](http://weitz.de/cl-recipes/) - A great set of Common Lisp patterns.
- [Object-Oriented Programming in Common Lisp by Sonya E. Keene](https://www.amazon.com/Object-Oriented-Programming-COMMON-LISP-Programmers/dp/0201175894) - An in-depth description of the CLOS, and shows how to use it with example applications.
- [The Art of the Metaobject Protocol by Gregor Kiczales, Jim des Rivieres, and Daniel G. Bobrow](https://www.amazon.com/Art-Metaobject-Protocol-Gregor-Kiczales/dp/0262610744/) - Describes the CLOS Metaobject Protocol (MOP).
  - [Chapters 5 and 6 (available online)](http://metamodular.com/CLOS-MOP/) - The specification of a metaobject protocol extension to CLOS, by Robert Strandh.
    - Superseded by the [modern public domain CLOS MOP specification](https://clos-mop.hexstreamsoft.com/) by Jean-Philippe Paradis ([Hexstream](https://github.com/Hexstream)).
  - [Adam Tornhill on AMOP](http://www.adamtornhill.com/reviews/amop.htm) - Recommends reading Practical Common Lisp, then  Object-Oriented Programming in Common Lisp, and then AMOP.

## Online Community
- The [Cliki](http://cliki.net) - The Common Lisp Wiki. A great resource for all things CL. Has a great [Getting Started](http://cliki.net/Getting+Started) page and an extensive list of [Lisp books](http://cliki.net/Lisp%20books).
- The #clschool, #lisp, #ccl, #sbcl and [other rooms](https://www.cliki.net/IRC) on the [Libera.Chat](https://libera.chat/) network are great places for learning about Common Lisp. ([Freenode should be avoided.](https://gist.github.com/joepie91/df80d8d36cd9d1bde46ba018af497409))
- [Lisp Subreddit](http://www.reddit.com/r/lisp/) - An active community, and has loads of useful links and reference documents in the sidebar.
  - [Common Lisp Subreddit](https://www.reddit.com/r/Common_Lisp) - The Subreddit for Common Lisp.
- [Exercism's Common Lisp track](https://exercism.org/tracks/common-lisp) - An excellent way to learn the language through practice, have your code reviewed, and to discuss solutions with other people.
- [Lisp Discord server](https://discord.gg/7tSq5EaA6Z) - Is a Discord for Lisp. Has a channel dedicated to Common Lisp and will happily answer questions.


## Library Management
These aren't libraries, but can help you find and install other libraries.
- [Quicklisp](https://www.quicklisp.org/beta) - A package management platform for Lisp libraries.
- [Quickdocs](http://quickdocs.org) - Documentation for projects in Quicklisp.
- [State of the Common Lisp Ecosystem, 2015](http://borretti.me/article/common-lisp-sotu-2015) - Article about what libraries you should use, and why.
- [Articulate Common Lisp](http://articulate-lisp.com/project/abcs.html) - Lists some useful libraries.


## Common Lisp Implementations
This section lists some common CL implementations and their manuals in alphabetical order. Unless otherwise noted, these are free software implementations. See also the Cliki's list of [free software Common Lisp Implementations](https://www.cliki.net/Common%20Lisp%20implementation).
- [Allegro Common Lisp (ACL)](https://franz.com/products/allegrocl/) - Commercial, but has a free [Express Edition](https://franz.com/downloads/clp/survey).
  - [ACL manual](https://franz.com/support/documentation/)
  - [Training videos on YouTube](https://www.youtube.com/channel/UCN36UrxtyNBJPaG0kmBJNRw)
- [CLISP](https://clisp.sourceforge.io)
  - [CLISP Manual](https://clisp.sourceforge.io/impnotes.html)
- [Clozure Common Lisp (CCL)](https://ccl.clozure.com)
  - [CCL manual](https://ccl.clozure.com/manual/)
- [Carnegie Mellon University Common Lisp (CMUCL)](https://www.cons.org/cmucl/)
  - [CMUCL manual and other useful information](https://www.cons.org/cmucl/doc/index.html)
- [Embeddable Common Lisp (ECL)](https://common-lisp.net/project/ecl/)
  - [ECL manual](https://common-lisp.net/project/ecl/static/manual/)
- [LispWorks](http://www.lispworks.com/products/index.html) - Commercial, but as mentioned previously, has a [Personal Edition](http://www.lispworks.com/downloads/index.html) with minor limitations.
  - [LispWorks manual](http://www.lispworks.com/documentation/index.html)
- [Steel Bank Common Lisp (SBCL)](http://www.sbcl.org) - My personal favorite.
  - [SBCL manual](http://www.sbcl.org/manual/index.html)
- [Scieneer Common Lisp (SCL)](http://web.archive.org/web/20171014210404/http://www.scieneer.com/scl/) - A commercial Linux and Unix implementation, but has an unrestricted free evaluation and non-commercial use version.
  - [SCL manual](http://web.archive.org/web/20171014210404/http://www.scieneer.com/scl/doc/)

## Credit
I got a lot of the information from [Rainer Joswig's Stack Overflow answer on learning Common Lisp](https://stackoverflow.com/a/7224914/1005039), and from the now-defunct Stack Overflow Documents site. The [Cliki's Getting Started](https://cliki.net/Getting%20Started) page was also invaluable.
