Disclosure: Class Central is learner-supported. When you buy through links on our site, we may earn an affiliate commission.

Best Courses Guides

15 Best Lisp Courses to Take in 2024

Here are the best online courses and resources to learn Lisp and its most popular dialects: Common Lisp, Scheme, Racket, and Emacs Lisp.

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 highly adaptable programming experience.

Are you intrigued? In this BCG, I’ve prepared and ranked 15 courses, covering four of the most popular Lisp dialects: Common Lisp, Scheme, Racket, and Emacs Lisp.

Here are my top picks. Click on one to skip to the course details:

Course Workload In Brief
1. Common Lisp (Neil Munro) 14–15 hours Best free comprehensive Common Lisp video course for beginners
2. Common Lisp programming: from novice to effective developer (Vincent Dardel) 3–4 hours Best professional Common Lisp video course for beginners
3. Practical Common Lisp (Peter Seibel) N/A Best free well-known Common Lisp chapter series for beginners
4. INF4820 — Algorithms for artificial intelligence and natural language processing (University of Oslo) 18 hours Best free Common Lisp AI / NLP course for experienced programmers
5. LispTutor Jr (Jarvis College of Computing and Digital Media) N/A Best free tutorial-based Common Lisp course for beginners
6. Common Lisp – “The Tutorial” Series (David Botton) N/A Best free Common Lisp article series on GUI programming for beginners
7. Lisp Tutorial (Derek Banas) 1–2 hours Best free short Common Lisp crash-course for beginners
8. Common Lisp Koans (Google) N/A Best free Common Lisp exercises for beginners and intermediates
9. Structure and Interpretation of Computer Programs (code_report) 13 hours Best free video course covering computing fundamentals in Scheme
10. Scheme: Feel the Cool (Andy Balaam) 2–3 hours Best free Scheme crash course for beginners
11. Quick: An Introduction to Racket with Pictures (racket-lang.org) N/A Best free short Racket course for complete beginners to programming
12. Beautiful Racket (Matthew Butterick) N/A Best free Racket course on designing programming languages for beginners
13. Learning Emacs Lisp (System Crafters) 7 hours Best free Emacs Lisp course on customizing Emacs for beginners
14. Exercism (Exercism) N/A Best free online Lisp coding exercise platform for all levels
15. Codewars (Codewars) N/A Best free online Clojure, Common Lisp, and Racket coding exercise platform for all levels

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:

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

Find your next course.

Best Courses Guides Methodology

I built this ranking 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 100K 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 and engaging content and they have to fit in a set of criteria and be ranked accordingly: comprehensive curriculum, affordability, release date, ratings and enrollments.

Course Ranking Statistics

Here are some aggregate stats about the ranking:

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

Without further ado, let’s go through the top picks.

1. Common Lisp (Neil Munro)

My first pick for the best Common Lisp course is Neil Munro’s Common Lisp YouTube series.

I chose this course as my first pick 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.

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

What You’ll Learn

First things first, you’ll set up Common Lisp on your PC and get ready to start building your very first CL program. And what better way to start than with the classic ‘Hello World!’ program?

Next, you’ll get right into action by writing a basic Coin Toss program and get a sense of how programmer-friendly the CL syntax and interpreter is. In fact, you’ll develop a variety of games, including the timeless classics Rock Paper Scissors, Hangman, and Tic Tac Toe. These will help you master common programming concepts and get a solid understanding of how they look in Lisp.

But what sets Lisp apart is its unique (and arguably more powerful) way of implementing these concepts. For instance, you’ll learn the `if` and `cond` conditional statements which are not only concise but also give you the ability to recover from errors through restarting. And let’s not forget about File IO and built-in packages such as ASDF and Rove for unit-testing.

Scratching the surface, you’ll also dive deep into Lisp’s distinctive features, such as macros, and learn why they’re so useful. And with a taste of functional programming under your belt, you’ll be introduced to higher-order functions such as maps, filters, and reduce, as well as anonymous functions and closures to help you write clean and correct code. You’ll then complement this with an exploration of OOP concepts (object-oriented programming) such as structs and classes to promote encapsulation.

And finally, you’ll have the opportunity to 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, and see how easy it is to do this after putting together everything you’ve learned so far.

How You’ll Learn

This course is 14–15 hours long. You’ll learn by watching the lecture videos and following along with the instructor as he codes throughout the course.

Channel Neil Munro
Provider YouTube
Instructor Neil Munro
Level Beginner
Workload 14–15 hours
Views 18K
Certificate None

Fun Facts

  • The course recommends you install Spacemacs to start coding in Common Lisp.
  • Neil is a senior software engineer and instructor, with programming experience in Python, Common Lisp, and JavaScript. He’s the head of backend engineering at Elixir. He’s also compiling the videos as blog posts which you can read here .

If you’re interested in this course, you can find more information about the course and how to enroll here.

2. Common Lisp programming: from novice to effective developer (Vincent Dardel)

My second pick for the best Common Lisp course is Common Lisp programming: from novice to effective developer by Vincent Dardel.

This paid Udemy course makes the learning process as painless as possible by not only covering 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, you’ll use an IDE of your choice, and you’ll 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.

Another nice thing this course provides is 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).

What You’ll Learn

After setting up your Common Lisp environment (installing SBCL, setting up CL on your favorite IDE or installing the Portacle IDE), you’ll start with the syntax and evaluation model of Lisp. One syntax you’ll need to get familiar with is S-expressions, which are the parentheses you keep seeing all over the place. They, as expressions, define the scope of variables and function. You’ll find them to be succinct when writing conditional expressions like `if` and `cond`.

Speaking of flow control, loops are another powerful tool in your arsenal. You’ll learn how to iterate over lists, vectors, and hash-tables, as well as over expressions. But be careful not to treat Lisp’s loops the same as loops in other languages.

In Common Lisp, functions are incredibly versatile, making functional programming a breeze. You’ll learn how to create functions, named or anonymous, and pass them around as higher-order functions like map or reduce. Tinkering around with generic functions will give you insight into CL’s object system. Yes, CL supports OOP, along with other unique constructs such as macros that manipulate and generate code at runtime.

Every programmer will eventually encounter the need to handle errors. Luckily, Lisp is the progenitor of exception handling. You’ll discover how to catch all sorts of errors and conditions, and even define your own. And with all that you’ve learned so far, how do you work with existing projects, or even start your own project in the first place? To answer this, you’ll understand what systems and packages are, and how they help you manage your code and dependencies.

How You’ll Learn

This course is 3–4 hours long. You’ll learn by watching the lecture videos, reading the suggested resources provided, and following along with the instructor as he demonstrates the code throughout the course.

Provider Udemy
Instructor Vincent Dardel
Level Beginner
Workload 3–4 hours
Enrollments 471
Rating 4.2 / 5.0 (67)
Certificate Paid

Fun Facts

  • This course offers the most choice out of the others in terms of editor selection (Emacs and Slime or the VSCode and Atom editors).
  • Vincent is a full-stack developer with 10 years of industry experience. Mainly in Python and JavaScript. Now, he’s a solo developer and creates products mainly in Common Lisp. He regularly writes about his Common Lisp journey on his blog and posts videos on his YouTube channel.
  • He is also one of the contributors and sponsors of the Common Lisp Cookbook Project.
  • By the way if you’re a student or you can’t afford the course, send Vincent an email to get a free udemy coupon!

If you’re interested in this course, you can find more information about the course and how to enroll here.

3. Practical Common Lisp (Peter Seibel)

My third pick for the best Lisp course (in a very loose sense of the word) is Practical Common Lisp, written by Peter Seibel.

I recommend this book 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 course’s 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.

You’ll need to have prior programming experience in order to take this course.

What You’ll Learn

The course begins with an introduction the most iconic programming environment — the REPL.  If you’ve tried other REPLs like Python or Ruby, you’ll find that you’re missing out on a lot! With Common Lisp’s REPL, you can execute individual lines of code in a source file while it’s running. This feature makes it an invaluable tool for remote debugging, even when dealing with spacecraft millions of miles away!

As you delve deeper into the course, you’ll find yourself fully immersed in the unique philosophy of Lisp’s syntax and semantics. You’ll discover how the S-expression syntax sets Lisp apart, and how this feature gives the compiler the ability to treat code as data, including powerful macros that can be used to extend the language itself. Lisp’s basic concepts will also be covered, such as variables, data types, functions, file I/O, and collections.

But that’s not all! Lisp has been a pioneer in many programming concepts, and you’ll dive into them too. You’ll study many of them, such as object oriented programming for representing real-world objects through polymorphism and classes, along with Lisp’s exceptional exception-handling system which allows you to restart a process seamlessly.

A book titled Practical Common Lisp would be disappointing if it didn’t contain any real-world projects. You’ll learn how to perform modern programming tasks, such as interacting with HTTP and databases, generating web pages, and even designing a domain-specific language, creating an interpreter, compiler, and more.

How You’ll Learn

This course consists of 32 chapters. You’ll learn by reading through the chapters and following along with the code examples provided. You’ll also learn a lot from implementing the practical chapters in the book.

Website gigamonkeys.com
Author Peter Seibel
Level Beginner
Workload N/A
Goodreads Rating 4.15 / 5.0 (769)
Certificate N/A

Fun Facts

If you’re interested in this course, you can find more information about the course and how to enroll here.

4. INF4820 — Algorithms for artificial intelligence and natural language processing (University of Oslo)

INF4820 is one of many of the interesting picks in this ranking, 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

You’ll begin this course first with an introductory walkthrough to artificial intelligence, machine learning, and natural language processing, along with their history and relation to Common Lisp.

Then, you’ll spend the next couple of lectures learning the fundamentals of Common Lisp til mastery. Through these lessons, you’ll become familiar with many of Lisp’s peculiar features like list manipulation and macros. You’ll also engrain functional programming concepts into your mind with topics such as recursion, anonymous functions, higher-order functions, and the likes.

Moving on, you’ll advance your knowledge of NLP by exploring vector space semantics, where you’ll learn how to tokenize and stem words in a given corpus. You’ll find this of great help when you classify and cluster words for text analysis and language translations. Furthermore, algorithms, data structures, and dynamic programming techniques needed for efficient computation will be discussed.

Hidden Markov Models allow you to predict the next word in a sentence. You’ll learn how to implement them in Lisp, as well as perform parsing of words using treebanks and Viterbi decoding.

How You’ll Learn

This course is 18 hours long. You’ll learn by watching the lecture videos and working on the exercises provided. If you’re stuck on any question, you can find the solution to your problem here.

Institution University of Oslo
Instructor Stephan Oepen and Murhaf Fares
Level Intermediate
Workload 18 hours
Views 4.2K
Certificate None

Fun Facts

  • Stephan Oepen is the Head of Department at the Department of Informatics and the manager of the Division for Machine Learning at the University of Oslo. He studied Linguistics, German and Russian Philology, Computer Science, and Computational Linguistics at Berlin, Volgograd, and Saarbrücken.
  • Murhaf Fares is currently a Senior Machine Learning Engineer at Fremtind, an insurance company. He earned his PhD in Computer Science at the University of Oslo.
  • The solutions to the exercises can be found here.

If you’re interested in this course, you can find more information about the course and how to enroll here.

5. LispTutor Jr (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 even a paper was 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 in order to take this course.

What You’ll Learn

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.

First, you’ll learn to adapt to the unique syntax of Lisp, which is actually much easier to get a hang of compared to other languages, as everything is an S-expression. You’ll also learn how lists are used to construct functions, and how functions can help you decompose large programs into smaller, separate ones. You’ll also get used to Lisp’s scoping rules, and create global and local variables.

Writing conditionals to ensure that a line of code is only executed if a condition is met, repeating code, or iterating through data, are essential pieces of programming. You can do these in Lisp with a macro, no doubt, but you’ll also discover the power of recursion — a function that calls itself in its own body — to solve complex problems by breaking them down into smaller ones. Lisp is a great language to test out this power. You’ll compute the power and factorial of numbers recursively, and also apply recursion to lists as well.

How You’ll Learn

This course has 5 sections in total.

Institution Jarvis College of Computing and Digital Media
Author Peter Hastings
Level Beginner
Workload N/A
Certificate None

Fun Facts

  • The original LispTutor was developed at Carnegie Mellon University by Reiser, Anderson, Corbett, Farrell, and others.
  • Peter Hastings is an Associate Professor at Jarvis College of Computing and Digital Media. His specific research interest is in intelligent tutoring systems, such as LispTutor Jr!

If you’re interested in this course, you can find more information about the course and how to enroll here.

6. Common Lisp – “The Tutorial” Series (David Botton)

David Botton’s “The Tutorial” series teaches you how to write actual Lisp programs — fast. It’ll give you a high-level summary of the entire language, such that any gaps in the tutorials can be filled in with more advanced resources. How high-level do I hear you ask? High-level enough that you can create a simple GUI-based game!

But learning Lisp isn’t just about writing programs; it’s also about having fun. David Botton’s relaxed yet expository style of writing will no doubt help you enjoy the learning process along the way.

The course assumes that you have some experience with computers and programming ideas.

What You’ll Learn

Every programming language is composed of symbols that are imbued with meaning. Lisp is no different. Lisp breaks symbols into three types: self-evaluating forms like numbers, symbols like variables, and lists. These are organized into packages, which you’ll learn to create and then load into packages.

Functions in Lisp are not just for transforming data, but can also be passed as arguments, forming the backbone of functional programming. For example, you can manipulate lists by passing a function to a map, which applies the function to each element of a list. Combined with control structures such as conditional statements and loops, you can write sophisticated yet easy-to-understand programs.

Lisp also offers macros, which extend the Lisp language by defining new syntax. Formats and Loop are actually examples of them, and as you may have noticed from their unique syntax, using macros helps abstract away the complexities of lower-level programming.

You have met lists, the most fundamental data structure in Lisp. It’s time to discover other important data structures like hashes and arrays. Hash tables allow for efficient lookups based on keys, while arrays can be used to represent multidimensional data. You’ll be surprised by how much these simple yet powerful data structures are used everywhere in Lisp!

Not only does Lisp support functional programming, but it also offers object-oriented programming with the CLOS (Common Lisp Object System). You can define classes that encapsulate data and methods, and even inherit from other classes with polymorphism with generic functions!

Finally, you’ll learn about concurrent and parallel programming, which may sound intimidating but are essential in today’s multi-core CPU world. You’ll end the course by mastering them to build a GUI-based game with CLOG in Common Lisp like a pro.

How You’ll Learn

This course consists of 15 chapters all together. You’ll learn by reading through each course chapter and applying what you’ve learned by following the code examples provided. You’ll also see a demonstration of a GUI-based game built in Lisp at the end of the course.

Organization The Common Lisp Omnificent GUI
Provider GitHub
Instructor David Botton
Level Beginner
Workload N/A
Stars 1.2K
Certificate None

Fun Facts

  • David Botton is a Rabbi, a doctor of Chinese medicine, and software engineer. He has been teaching Torah classes for over 25 years, and developing software for another 5 more years.

If you’re interested in this course, you can find more information about the course and how to enroll here.

7. Lisp Tutorial (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.

What You’ll Learn

After setting up Common Lisp on your Mac or Windows PC, you’ll start by digging into the syntax. For example, you’ll learn that expressions in Lisp are constructed as forms, that is, lists with a command function name at the beginning. Though it may seem weird at first, you’ll eventually see how simple yet expressive your code can become.

WIth forms, controlling the flow of your program is a breeze. If statements and cond statements can test multiple conditions, whereas when and unless statements can only have one condition. You’ll also learn how to iterate through lists with loop statements and DoTimes statements.

Next, you’ll take a look at some in-built functions (such as car, cdr, and mapcar), as well as practice writing your own functions, with an emphasis on recursion, anonymous functions, and higher-order functions. Macros are another superpower Common Lisp has, and you’ll see how it extends the language by generating new syntax.

Finally, you’ll cover some of the Object-Oriented parts of Lisp, such as classes, structures, polymorphism, and inheritance.

How You’ll Learn

This course is 1–2 hours long. You’ll learn by watching the lecture videos and reading the lectures.

Provider YouTube
Instructor Derek Banas
Level Beginner
Workload 1–2 hours long
Views 430K
Likes 5K
Certificate None

Fun Facts

If you’re interested in this course, you can find more information about the course and how to enroll here.

8. Common Lisp Koans (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.

Each koan presents a problem, puzzle, or project for you to solve by writing code that meets certain requirements, and each koan gets progressively harder and harder. You’ll then run a set of automated tests to check whether their solution is correct. This way, you’ll improve your Common Lisp programming skills through practice.

It follows a structured approach where the learner is presented with a series of broken unit tests that highlight different Common Lisp language features.

What You’ll Learn

Your journey to Common Lisp enlightenment begins with basic syntax and language constructs, such as variables, functions, and conditionals. With steady practice, you’ll gain an understanding of how common data types such as strings, lists, arrays, and hash tables, are represented in Lisp.

Through your studies, you’ll develop a deep appreciation for the importance of control flow constructs like loops and iterations, learning how to utilize them to navigate the challenges of programming. The teachings of both the object-oriented way and the fundamental functional programming way will be introduced, where you’ll learn the beauty behind the mantra ‘code is data, and data is code’.

You’ll then approach the mysteries of macros and understand their power to generate code at run-time. Finally, you’ll meditate on the nature of concurrency and parallelism with threads and semaphores.

How You’ll Learn

This set of koans consists of 32 koans in total. You’ll work through each koan through test-driven development. That means you’ll run the koan and see it fail, make the test pass (green), and reflect upon the test and see how you can improve the code to better communicate its intent.

Institution Google
Provider GitHub
Level All Levels
Workload N/A
Stars 3K
Certificate None

Fun Facts

  • The Common Lisp koans are based on the Python koans and Ruby koans projects.
  • Fun fact, Google has their own Common Lisp style guide!

If you’re interested in this course, you can find more information about the course and how to enroll here.

9. Structure and Interpretation of Computer Programs (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 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.

What You’ll Learn

The first chapter introduces you to elementary building blocks of programming by focusing on procedures and processes as the basic elements of abstraction. You’ll delve into higher-order functions, recursion, and iteration, and build small programs and algorithms.

But procedures don’t work standalone. After all, they need something to operate on. Hence, while procedures are the yin, the second chapter of the course introduces you to the other half or the yang — data. Fascinatingly, data can be engineered and constructed to form data structures, and the way we design these data structures can heavily influence the performance of our program as well as how we reason about them.

Expanding on this concept, the third chapter introduces you to object-oriented programming, which defines a system as a set of interconnected objects that have states and methods. You’ll encounter more data structures, tackle the challenges of running multiple processes at the same time, and learn how streams, which are sequences of values generated on demand, relate to objects.

The fourth chapter of the course covers metalinguistic abstraction, the ability to create and manipulate programming languages. One of the most important ideas of metalinguistic abstraction is that the expressions have meanings, and meanings can be determined by another program. You’ll understand the underlying mechanisms of programming languages, such as macros and interpreters in the fourth chapter.

The fifth and final chapter levels everything down to the most primitive abstraction of programs — register machines. You’ll learn how to design and simulate your own register machines that can read and execute programs, and understand how memory is managed using garbage collection. You’ll explore the alternative strategy to interpreters, that is compilers, and learn how they translate a source program into the machine’s native language through lexical analysis, parsing, and interpretation.

How You’ll Learn

This course is 13 hours long. You’ll learn by watching the lecture videos as Conor illustrates the principles expounded in SICP, and completing the many course exercises available.

Channel code_report
Provider YouTube
Instructor Conor Hoekstra
Level Intermediate
Workload 13 hours
Enrollments 42K
Certificate None

Fun Facts

  • Conor works as a Research Scientist at NVIDIA, where he focuses on developing array programming models and languages. He has a deep interest in programming languages, algorithms, and writing elegant code.
  • Conor founded and organizes the Programming Languages Virtual Meetup, maintains a YouTube channel, and hosts two podcasts, “Algorithms + Data Structures = Programs” and “ArrayCast”. In addition, he frequently speaks at conferences on these topics.
  • You can find an (unofficial) book of SICP online here.

If you’re interested in this course, you can find more information about the course and how to enroll here.

10. Scheme: Feel the Cool (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

The fundamental thing you need to know about Lisp is how you write expressions, of course. You’ll learn about pairs, which make up lists, and navigate through lists with conditionals and loops. Then, you’ll explore closures, functions that carry their environment around with them. These are useful for testing code output, holding state, and even designing classes. You’ll also explore nameless functions called lambdas and understand why namelessness can help you create elegant programs.

Recursion is the beating heart of Scheme. You’ve used recursive functions such as fold and map, but now you’ll dive even deeper into the topic of recursion. With examples like factorial and Fibonacci, you’ll see just how beautiful recursion can be. And you’ll also learn what tail call optimization means in the context of recursion.

We keep saying that Scheme treats data as code, but what exactly does that mean? You’ll find out the answer to this when you later take a look at one of the most powerful yet unfamiliar features of Scheme that plays a huge role in ensuring generic type safety — quotations.

For ultimate flexibility, Scheme provides the ability to make your own language constructs using macros, thereby extending the language on your own behalf. You’ll get to see some awesome examples of this in action, and finally compare the Scheme way with how other languages like Python or Java would accomplish the same thing.

How You’ll Learn

This course is 2–3 hours long. You’ll learn by watching the lecture videos and following along with the code examples Andy brings up throughout the course.

Channel Andy Balaam
Provider YouTube
Level Beginner
Workload 2–3 hours
Views 77K
Likes 900
Certificate None

Fun Facts

  • 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.

If you’re interested in this course, you can find more information about the course and how to enroll here.

11. Quick: An Introduction to Racket with Pictures (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

After installing Racket’s preferred IDE, DrRacket, you’ll begin writing expressions that generate shapes in the REPL to get a feel of the language. The shapes you’ve created can be given names by ‘binding’ the values to a symbol. This way, you can reuse them any time you want.

The names you’ve given a shape are permanent, but what if you want them to be temporary instead? Local bindings allow you to bind a value to a symbol for as long as the expression lasts, otherwise known as a scope. This simplifies how much you need to write.

Functions are pretty handy as they allow you to reuse code, just like how binding does. Though Racket has its own built-in functions, you can create your own functions pretty easily (you can also show off your knowledge of local bindings here).

But another cool thing about functions is that they can operate over a list, which are sequences of data. For example, given a list of shapes, you can make each shape in the list a specific color. Once you’ve created the functions you need, you can reuse them elsewhere (even online!) by exporting them as packages.

Lastly, you’ll explore some interesting features of the language, such as macros which allow you to extend the language’s syntax to suit your own needs, as well as its object system which can sometimes work better than functions!

How You’ll Learn

This course is made up of 12 chapters. You’ll learn by reading through the course materials and following the examples provided.

Provider docs.racket-lang.org
Authors Matthew Flatt
Level Beginner
Workload N/A
Certificate None

Fun Facts

If you’re interested in this course, you can find more information about the course and how to enroll here.

12. Beautiful Racket (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 ranking. 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.

What You’ll Learn

There are 11 tutorials in this course.

The first tutorial will have you build stacker, a simple program­ming language that acts as a stack-based calcu­lator. Finding it much easier than you expected, you’ll also have the chance to reimplement your language in a functional-style or with Racket macros.

The previous tutorial held your hands a bit, but now it’s time to let go of the training wheels. You’ll implement the grammar of the bf language, and ‘read’ bf with a parser and tokenizer to convert it into program representation.

Now that you’ve tried your hands at designing languages, let’s create a more useful language, such as jsonic, which compiles Racket expressions to JSON. Surprisingly enough, you’ll implement this in under 50 lines of code, which shows how expressive Racket is! Indeed, designing domain-specific languages might seem like a huge undertaking at first, but Racket makes it easy, as you’ll realize when you make a DSL for work or even for play.

The final series of tutorials will cover something more challenging — recreating the fully-fledged BASIC programming language in Racket. Why BASIC? Because it incorporates low-level features (GOTOs) and high-level features (RETURNs), as well as other unusual program-control features that you’ll simulate within Racket. Hence, everything you’ve learned so far will help you build a programming language suitable for real-world tasks.

How You’ll Learn

The tuto­rials take you through a series of program­ming-language projects of increasing diffi­culty. The tuto­rials are cumulative, so it’s fine to jump ahead. While doing the tutorials, you’ll supplement your knowledge with the bite-sized explainers of various Scheme topics.

Website beautifulracket.com
Author Matthew Butterick
Level Beginner
Workload N/A
Certificate None

Fun Facts

  • The course website itself is made with a programming language called Pollen that the author created with Racket.

If you’re interested in this course, you can find more information about the course and how to enroll here.

13. Learning Emacs Lisp (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

This course begins with an introduction to the fundamentals of Lisp that you can find in every Lisp language, such as its concise yet expressive syntax. It’ll take some practice to get used to, but once you get used to it you’ll wonder why other languages aren’t written the same way!

Then, you’ll cover basic programming concepts. For example, you’ll see that ELisp has familiar datatypes like integers, characters, sequences, strings, and the most important datatype of them all — lists.

You’ll also learn how to define functions, both named and unnamed, in Lisp. Commands are another type of functions which are interactive, and you’ll also learn how to write and use them. Also, you’ll figure out how to use conditionals and loops in code for control flow, as well as take care of variables and their scopes, as they work a bit differently in Lisp-like languages.

With all of that out of the way, you’re now ready to start customizing the functionality and feel of your Emacs editor! First, you’ll work on a practical example of reading and writing the contents of buffers. Then, you’ll manage files and directories. Finally, you’ll create custom minor modes and hooks that ‘attach’ to your Org Mode configuration files. All of these topics you’ve learned will aid you on your quest to build dotcrafter.el.

How You’ll Learn

This course is 7 hours long. The video lectures are presented in a slideshow format. At the end of each lecture, the instructor does an exercise.

Channel System Crafters
Provider YouTube
Instructor David Wilson
Level Beginner
Workload 7 hours
Views 47K
Likes 1.3K
Certificate None

Fun Facts

  • System Crafters is the home for computer enthusiasts who love to craft their own computing experience. They talk about Emacs, GNU/Linux, Guix, and other assorted tools that allow you to build a fully custom computing experience that YOU control.

If you’re interested in this course, you can find more information about the course and how to enroll here.

14. Exercism (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.

What You’ll Learn

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

Common Lisp comes with a structured learning syllabus which makes it suitable for beginners with no knowledge of CL. You’ll start with the basics such as the 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.

How You’ll Learn

This course is self-paced, so you can take all the time you need to complete the hands-on programming exercises. Each exercise comes with automatic feedback of your code as well as the ability to request personal mentoring to help you understand your code’s strengths and flaws.

Provider Exercism
Level All Levels
Workload N/A
Certificate None

Fun Facts

  • Exercism provides exercises on 50+ programming languages like Python, Kotlin, F#, and even WebAssembly.
  • Their mission is to help everyone get really good at programming, regardless of their background, share the love of programming, and help people upskill as part of their upward social mobility.

If you’re interested in this course, you can find more information about the course and how to enroll here.

15. Codewars (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!

What You’ll Learn

The language with the most number of katas is Clojure, with over 450 of them. The next most popular language is Racket, with 250+ katas, and lastly the language with the least number of katas with around 30.

The easiest challenges available usually involve solving a simple use case provided. They may include topics such as strings or mathematics.

Some of the harder challenges you’ll encounter revolve around data structures and algorithms, where you’ll need to implement these in code.

How You’ll Learn

You’ll learn by solving the coding challenges, and after submitting your solution, check your solution with other user-submitted solutions.

Provider Codewars
Level All Levels
Workload N/A
Certificate None

Fun Facts

  • The platform is owned and operated by Qualified, a technology company that provides a platform for assessing and training software engineering skills.

If you’re interested in this course, you can find more information about the course and how to enroll here.

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

Elham Nazif Profile Image

Elham Nazif

Part-time content writer, full-time computer science student.

Comments 1

  1. Saifi Khan

    Elham thanks so much for sharing this updated list of LISP courses available on the web.

    Much appreciated.

    Reply

Leave a reply

Your email address will not be published. All comments go through moderation, so your comment won't display immediately.

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Browse our catalog

Discover thousands of free online courses from top universities around the world like MIT, Stanford, and Harvard.

Browse all subjects