Lisp, a high-level programming language that has been around for over half a century, whose age is second only to Fortran, is still considered by many to be one of the most influential programming languages in history.

What makes Lisp so unique compared to other C-like languages? Whereas C starts with low-level assembly instructions and builds up higher and higher levels of abstraction, Lisp starts with a strong mathematical foundation in Lambda calculus and implements it on a machine. This fundamental difference can be felt from the way the language feels.

Lisp is loved for its simplicity and expressiveness. It is easy to learn, yet powerful enough to handle complex computations and logic. Its syntax is based on S-expressions, allowing for flexible manipulation of data structures. And here’s the kicker, Lisp is homoiconic: data is code and code is data. Hence, the language is easy to extend as evidenced by its macro system, and combined with dynamic typing, Lisp provides a highly adaptable programming experience.

Are you intrigued? In this Best Courses Guide (BCG), I’ve selected 15 courses, covering four of the most popular Lisp dialects: Common Lisp, Scheme, Racket, and Emacs Lisp.

Click on the shortcuts for more details:

• Top Picks
• What is Lisp?
• Why You Should Trust Us
• Courses Overview
• How We Made Our Picks and Tested Them

Here are our top picks

Click to skip to the course details:

Related Guides

• Web Development
• Clojure
• CSS Layout
• JavaScript
• React

Recommended Guides

• C Programming
• Kotlin
• C#
• Flutter & Dart
• Swift

Trending Guides

• Drawing
• American Sign Language (ASL)
• SQL
• Programming
• AutoCAD

What is Lisp?

Lisp is a family of programming languages first developed by John McCarthy and his team of students in 1958 at MIT. It was originally created as a practical mathematical notation for computer programs, which Fortran couldn’t handle, but thanks to a series of clever insights (and some luck), it became one of the most elegant distillations of the principles of computation, attaining a sort of holy reverence in the programming community.

The ingenuity of Lisp comes from the fact that the entire language is defined in terms of itself from a very small set of basic rules (5 primitive operations and 1 conditional expression). What this means is that only six instructions were needed to be written in machine code before fitting them together. Thus amazingly, it took only two years for John McCarthy to complete and publish his famous paper on Lisp.

Lisp stands for “LISt Processor”, as its entire source code is made up of data structures called lists, or S-expressions. This meant that Lisp programs can manipulate and ‘process’ its own source code as data structures, which opened up a world of possibilities for extending the language at one’s own behest. And as AI needed symbolic expressions to represent code as human-readable data and vice-versa, Lisp quickly became the mother tongue of AI researchers.

Many of the ideas in computer science were pioneered by Lisp, from the simplest concepts such as conditionals, recursion, and the REPL, and much more complex concepts like tree data structures, higher-order functions, and garbage collection. Not only that, it heavily influenced the development of programming languages that came after it (JavaScript, Python, Ruby, and C#). Though many languages based themselves on C, over the years they gradually began to incorporate Lispy features into their libraries.

Lisp has changed a lot in the six decades since its early days. Many dialects of Lisp were born and died out. The most popular Lisp dialects, sorted by popularity, are as follows:

• Clojure: A modern, functional programming language designed for concurrency and interoperability with Java. Used by Walmart, Netflix, Cisco, and others
• Common Lisp: A powerful, multi-paradigm language with a rich library of functions and macros, and an interactive development environment. Used in production code at companies like ITA Software by Google, pgloader by PostgreSQL organization, and Rigetti Quantum Computing. Also, a game was created with it
• Emacs Lisp: A dialect of Lisp used to extend the Emacs text editor
• Scheme: A minimalist dialect of Lisp with a focus on simplicity, elegance, and expressiveness
• Racket: A general-purpose programming language descended from Scheme, with a focus on language-oriented programming.

I have not included Clojure in this guide as I have already written a guide on the best Clojure courses. Instead, the best courses of the Common Lisp, Emacs Lisp, Scheme, and Racket will be listed here.

Why You Should Trust Us

Class Central, a Tripadvisor for online education, has helped 60 million learners find their next course. We’ve been combing through online education for more than a decade to aggregate a catalog of 200,000 online courses and 200,000 reviews written by our users. And we’re online learners ourselves: combined, the Class Central team has completed over 400 online courses, including online degrees.

Courses Overview

• This guide contains 4 different Lisp dialects: Common Lisp, Scheme, Racket, and Emacs Lisp
• All of the courses are free, except for one
• The most common provider is YouTube, followed by GitHub, Udemy, and an assortment of independent websites.

Best Free Comprehensive Common Lisp Video Course for Beginners (Neil Munro)

I chose Common Lisp YouTube series for this guide because it’s free and comprehensive, covering many of the topics essential to Common Lisp from the basic syntax, to functional programming, to object-oriented programming. Plus, the course emphasizes understanding through building projects, of which there are plenty in this course.

Familiarity with programming is a prerequisite to take this course. The course also recommends you install Spacemacs to start coding in Common Lisp.

In this course, you will:

• Start with the classic ‘Hello World!’ program
• Write a basic Coin Toss program to get a sense of the CL syntax and interpreter
• Develop a variety of games, including Rock Paper Scissors, Hangman, and Tic Tac Toe, to master common programming concepts
• Learn unique and powerful ways of implementing concepts in Lisp, such as ‘if’ and ‘cond’ conditional statements
• Explore File IO and built-in packages such as ASDF and Rove for unit-testing
• Dive deep into Lisp’s distinctive features, such as macros, and understand their usefulness
• Get a taste of functional programming with higher-order functions like maps, filters, and reduce, as well as anonymous functions and closures for writing clean and correct code
• Complement this with an exploration of OOP concepts like structs and classes to promote encapsulation
• Apply your knowledge and skills by working on a final project where you’ll build a Turing machine, the simplest method of simulating any computer program.

Best Professional Common Lisp Video Course for Beginners (Vincent Dardel)

Common Lisp programming: from novice to effective developer by Vincent Dardel is a Udemy course that makes the learning process as painless as possible. It covers not only the language but also the current state of CL tooling and ecosystem. You’ll write and run Lisp code from sources or by building standalone binaries, use an IDE of your choice, and understand the interactive nature of both Common Lisp and the debugger. By the end of this course, you’ll have enough knowledge to build your own application for the real world, just like Vincent.

This course offers the most choice in terms of editor selection (Emacs and Slime or the VSCode and Atom editors). It also provides links to resources for beginners to help you get started on your Common Lisp journey.

The course assumes you have some basic knowledge of a programming language (e.g., variables and functions).

In this course, you’ll learn:

• How to set up a Common Lisp environment, including SBCL and popular IDEs
• The syntax and evaluation model of Lisp, including S-expressions and their role in defining variable and function scope
• Flow control with conditional expressions like if and cond, and how to use Lisp’s powerful looping constructs
• Functional programming concepts, including creating and using higher-order functions
• Object-oriented programming in Common Lisp and unique constructs like macros
• Error handling and exception management in Lisp
• How to work with existing projects and manage your own code using systems and packages.

Best Free Well-Known Common Lisp Chapter Series for Beginners (Peter Seibel)

I recommend Practical Common Lisp, written by Peter Seibel as it gives an excellent overview of the philosophy behind Lisp, helping you ease your fears of Lisp’s distinct syntax and structure. Of course, you’ll also study the syntax and semantics of Lisp, including the basic concepts found in most programming languages such as collections, functions, and classes, but also unique concepts that Lisp itself invented, like recursion, cons cells, macros, and exceptions.

If you’re worried that the book is purely theoretical — don’t! Around one third of the chapters are devoted to building practical projects: spam filters, databases, web servers, interpreters, and more. The complete source code for these are on GitHub.

The book is quite popular in the Common Lisp world. You can find study groups like this one to follow along if you prefer video lectures.

Prior programming experience is recommended to fully benefit from this course.

What you’ll learn:

• Use the powerful Common Lisp REPL for interactive programming and debugging
• Understand Lisp’s unique S-expression syntax and how it enables code-as-data
• Master basic Lisp concepts: variables, data types, functions, file I/O, and collections
• Explore Lisp’s pioneering programming concepts like object-oriented programming and exception handling
• Create practical projects including:
  • Interacting with HTTP and databases
  • Generating web pages
  • Designing domain-specific languages
  • Building interpreters and compilers
• Implement powerful macros to extend the language itself
• Understand Lisp’s philosophy and its impact on programming paradigms.

Best Free Common Lisp AI/NLP Course for Experienced Programmers (University of Oslo)

INF4820 is one of many of the interesting picks in this guide, where the course is focused more on a particular topic than the language itself. Nevertheless, you’ll gain a lot of experience using Common Lisp anyways, as everything in the course from the slides to the exercises expects you to know CL. And if you are also interested in AI and NLP, this course kills two birds with one stone!

In this Masters-level course, you’ll explore foundational theory in AI and NLP, and learn how to implement these concepts using Common Lisp.

To take this course, you should have knowledge of computational linguistics (theory of formal languages and grammars).

What you’ll learn:

• Introduce AI, machine learning, and NLP, relating them to Common Lisp
• Master the fundamentals of Common Lisp
• Explore Lisp’s unique features like list manipulation and macros
• Learn functional programming concepts like recursion and higher-order functions
• Advance NLP knowledge with vector space semantics
• Tokenize and stem words for text analysis and translations
• Discuss algorithms, data structures, and dynamic programming for efficient computation
• Implement Hidden Markov Models in Lisp
• Parse words using treebanks and Viterbi decoding.

Best Free Tutorial-Based Common Lisp Course for Beginners (Jarvis College of Computing and Digital Media)

This course, LispTutor Jr, is the best introductory hands-on course to the bare-bones basics of Lisp.

LispTutor was a cognitive tutoring program developed in 1984 used to help students train their programming skill at Carnegie-Mellon University. It worked by giving students exercises and watching them iteratively type the solution in Lisp, and giving comments and feedback based on their answers. This program was so successful that a paper was even written about it!

LispTutor Jr is the simplified version of that system that still works very much the same way the original does. By going through the notes and doing the exercises, you’ll have a firm grasp of Lisp syntax and semantics by the end of the course.

You should have some experience with programming to take this course.

There are two modes to this program: traditional, which presents instructive tests and related exercises one-by-one, or mastery, which allows you to pick and choose the text and exercises to read and practice.

As for the syllabus, it consists of 5 sections covering:

• Learn Lisp’s unique S-expression syntax
• Understand function construction using lists and program decomposition
• Master scoping rules for global and local variables
• Write conditionals for conditional execution, repetition, and iteration
• Explore recursion for solving complex problems by breaking them down into smaller ones
• Compute power and factorial recursively
• Apply recursion to lists.

Best Free Common Lisp Article Series on GUI Programming for Beginners (David Botton)

David Botton’s “The Tutorial” series teaches you how to write actual Lisp programs — fast. It provides a high-level summary of the entire language, comprehensive enough that you can create a simple GUI-based game by the end. David’s relaxed yet expository writing style makes the learning process enjoyable.

This course assumes some experience with computers and programming ideas. It’s an excellent resource for those who want to quickly grasp Common Lisp’s capabilities, especially in GUI programming.

What you’ll learn:

• Understand Lisp symbols: self-evaluating forms, variables, and lists
• Create and load packages
• Master functional programming concepts, including passing functions as arguments
• Use control structures like conditional statements and loops
• Extend Lisp language with macros, including examples like Formats and Loop
• Work with various data structures: lists, hash tables, and arrays
• Explore object-oriented programming with CLOS (Common Lisp Object System)
• Define classes, encapsulate data and methods, and implement inheritance
• Learn concurrent and parallel programming
• Build a GUI-based game using CLOG in Common Lisp.

Best Free Short Common Lisp Crash-Course for Beginners (Derek Banas)

Derek Banas’ Lisp Tutorial covers everything one can learn by reading a 400-page book on Lisp in under two hours! This crash course is great for beginners as the instructor ensures you don’t get bogged down by the details by gently introducing Lisp syntax and concepts, one by one.

By the end of this, you’ll have a well-grounded understanding of Common Lisp.

You’ll learn:

• Setting up Common Lisp on Mac or Windows
• Syntax, expressions, and forms
• Program flow with forms
• If and cond statements for multiple conditions
• When and unless statements for single conditions
• Looping through lists
• Built-in functions like car, cdr, and mapcar
• Writing functions with recursion, anonymous, and higher-order functions
• Macros for extending the language
• Object-Oriented concepts like classes, structures, polymorphism, and inheritance.

Best Free Common Lisp Exercises for Beginners and Intermediates (Google)

Common Lisp Koans is a series of exercises designed to teach Common Lisp, similar to other language-specific koans like Ruby Koans and Python Koans. This free resource provides a structured approach to learning Common Lisp through practice, presenting broken unit tests that highlight different language features.

Each koan presents a problem, puzzle, or project for you to solve by writing code that meets certain requirements, with increasing difficulty as you progress. You’ll run automated tests to check whether your solution is correct, improving your Common Lisp programming skills through hands-on practice.

What you’ll learn:

• Master basic Common Lisp syntax and language constructs
• Work with common data types: strings, lists, arrays, and hash tables
• Utilize control flow constructs like loops and iterations
• Explore both object-oriented and functional programming paradigms
• Understand the ‘code is data, and data is code’ philosophy
• Develop macros to generate code at run-time
• Practice concurrency and parallelism with threads and semaphores
• Improve your problem-solving skills through test-driven development
• Gain hands-on experience with 32 progressively challenging koans
• Learn to write, test, and refine Common Lisp code efficiently.

Best Free Video Course Covering Computing Fundamentals in Scheme (code_report)

Structure and Interpretation of Computer Programs is one of the most legendary books / courses from MIT ever published. And it turns out that the authors of this course chose Scheme as the language to show beginner computer science students the wonders of programming and computation!

Conor Hoekstra’s series of video lectures covering the book presents its contents in an easy-to-digest manner. Though the aim of the book admittedly is not to teach Scheme, the code examples and question problems are in Scheme, so you’ll naturally pick it up along the way, all while learning the absolute fundamentals of building computer programs!

Some experience with programming is required to take this course.

You’ll learn:

• Introduction to programming fundamentals, focusing on procedures and processes
• Explore higher-order functions, recursion, iteration, and build small programs
• Data engineering, data structures, and their impact on performance
• Object-oriented programming, interconnected objects with states and methods
• Metalinguistic abstraction, creating and manipulating programming languages
• Register machines, memory management, and compilers.

You’ll learn by watching the lecture videos as Conor illustrates the principles expounded in SICP, and completing the many course exercises available. You can find an (unofficial) book of SICP online here.

Best Free Scheme Crash Course for Beginners (Andy Balaam)

Scheme is simple, weird and cool. Simple as in there’s only one thing you can do; weird as in it’s functional and it treats code as data and data as code; cool as in its metaprogramming is just programming.

Intrigued? Andy Balaam’s course Scheme: Feel the Cool covers the essentials of programming in Scheme. By the end of the course, you’ll be confident enough to work independently on your own Scheme projects.

You should have some prior experience with programming prior to taking this course.

What you’ll learn:

• Learn about pairs and navigation in lists
• Explore closures and namelessness for elegant programming
• Dive into recursion, including examples and tail call optimization
• Understand data as code, quotations, and macros
• Compare Scheme’s approach to other languages.

Andy has presented a shorter 1.5 hours version of his Scheme: Feel the Cool course at the 2018 ACCU Conference. You can find the PDF of the slides used in the video description.

Best Free Short Racket Course for Complete Beginners to Programming (racket-lang.org)

Learn the basics of Racket as quickly as possible with one of its picture-drawing libraries!

This introduction to Racket with pictures purposely avoids many of the traditional aspects of Lisp or Scheme, such as prefix notation and quoting lists. Instead, you’ll focus on the parts Racket programmers primarily use: functions, records, objects, exceptions, regular expressions, modules, and threads. This is because unlike a minimalist language like Scheme, Racket is a rather rich language with many libraries and tools available in its standard library.

This course is suitable for complete beginners — no knowledge of programming is required!

What you’ll learn:

• Start writing expressions in the REPL using DrRacket
• Name shapes by binding values to symbols
• Local bindings bind values temporarily
• Functions enable code reuse
• Create custom functions in Racket
• Functions can operate on lists
• Export functions as packages for reuse
• Extend the language syntax with macros
• The object system is an alternative to functions.

Best Free Racket Course on Designing Programming Languages for Beginners (Matthew Butterick)

Want to design your own programming language, without the hassle of doing everything from scratch?

Beautiful Racket is another unique course in this guide. Here, you’ll learn language-oriented programming — how to design and implement programming languages.

Why language-oriented programming? By making programming languages, you’ll become more familiar with the way programming languages work. Therefore, you’ll not only become a better programmer, but you’ll also have a greater appreciation (or perhaps disdain) for the languages you use everyday.

No knowledge of Racket required! The course only assumes that you’ve done some programming with any language.

There are 11 tutorials in this course in which you’ll learn:

• Create a simple stack-based calculator language (stacker)
• Reimplement stacker in a functional style or with Racket macros
• Implement the grammar of the bf language
• Parse and tokenize bf to convert it into a program representation
• Create a more useful language like jsonic that compiles Racket expressions to JSON
• Implement jsonic in under 50 lines of code
• Design a DSL for work or play
• Recreate the BASIC programming language in Racket
• Simulate low-level and high-level features in Racket
• Build a programming language suitable for real-world tasks.

Best Free Emacs Lisp Course on Customizing Emacs for Beginners (System Crafters)

The best Emacs Lisp course that I can recommend is this practical series called Learning Emacs Lisp by the channel System Crafters (real name David Wilson)

Emacs is highly popular due to its extensibility. As a wise person once said, just as car enthusiasts like to work on their own cars, programmers like editors that they can program.

One of the reasons why Emacs is so customizable is because of its own Lisp dialect, Emacs Lisp. Through hands-on exercises, you’ll work on a project called dotcrafter.el that helps you manage your dotfiles.

System Crafters has a Discord channel, where you can ask questions and hang out with the community members.

What you’ll learn:

• Introduction to Lisp fundamentals
• Practice expressive syntax
• Basic programming concepts and datatypes
• Define named and unnamed functions
• Interactive commands
• Control flow with conditionals and loops
• Variables and scopes in Lisp
• Customize Emacs editor
• Read and write buffers
• File and directory management
• Create custom minor modes and hooks for Org Mode
• Topics learned will help build dotcrafter.el.

Best Free Online Lisp Coding Exercise Platform for All Levels (Exercism)

Exercism is an free online open-source coding platform that helps programmers get really good at programming.

How? By offering developers a variety of interesting and unique exercises that challenges their skills and tests their understanding of different programming concepts. But you don’t need to be an expert at the language to try your hands on the exercises — you’ll do the exercises step-by-step so that you fully understand each concept before moving on to the next one. After all, the best way to learn is by doing!

But what’s more important than doing arguably is reflecting on what you’ve done. Though each submitted solution is automatically checked, you can also compare your solutions with those of other users, so you can see how others have tackled the same problem and learn from them. What’s more, you can even request free mentoring from a programming expert in the language you’re learning, giving you personalized guidance to help you improve your skills even further.

So if you’re learning Common Lisp, Clojure, Racket, Scheme, or Emacs Lisp, consider supplementing your learning by doing the exercises on Exercism.

The most comprehensive of the Exercism courses is Common Lisp and Clojure, followed by Racket, Scheme, and Emacs Lisp:

• Common Lisp has a structured learning syllabus
• Suitable for beginners with no knowledge of CL
• Start with the basics:
  • Building blocks of S-expressions
  • Doing arithmetic
  • Writing conditional statements
  • Working with loops to deal with lists and vectors
  • Implementing and using functions
  • And much more.

Meanwhile, the other languages do not have a structured syllabus, but they do come with exercises of difficulties ranging from easy to hard. These exercises come with a variety of problems from solving mathematical problems to implementing algorithmic solutions.

Best Free Online Clojure, Common Lisp, and Racket Coding Exercise Platform for All Levels (Codewars)

Another platform similar to Exercism, but more focused on gamification and competition is Codewars.

Codewars helps developers improve their coding skills by solving challenges (called katas) divided into levels based on their difficulty. Depending on the difficulty level of the challenge solved, you’ll earn points called kyus and advance your ranking in the community.

Codewars is also more community-focused. Users can create their own challenges and share them with the community. After completing a challenge, you can see other people’s solution. This is useful especially since many of the challenges require a deep understanding of a language’s coding concepts and algorithms, so you’ll see a mix of efficient and elegant solutions.

However, Codewars offer less variety of languages compared to Exercism, so you can only find Common Lisp, Clojure, and Racket exercises. Nevertheless, expect the exercises to be challenging!

Clojure has the most katas (450+), followed by Racket (250+). The easiest challenges focus on simple use cases like strings or mathematics. Harder challenges revolve around data structures and algorithms.

Want to share any courses or resources that I may have missed? Anything which I’ve overlooked in my guide? Feel free to leave a comment below!

How We Made Our Picks and Tested Them

I built this guide following the now tried-and-tested methodology used in previous Best Courses Guides (you can find them all here). It involves a three-step process:

1. Research: I started by leveraging Class Central’s database with 200K online courses and 200K+ reviews. Then, I made a preliminary selection of Lisp courses by rating, reviews, and bookmarks.
2. Evaluate: I read through reviews on Class Central, Reddit, and course providers to understand what other learners thought about each course and combined it with my own experience as a learner.
3. Select: Well-made courses were picked if they presented valuable, engaging content and fit a set of criteria: comprehensive curriculum, affordability, release date, ratings and enrollments

Fabio revised the research and the latest version of this article.