It is with great pleasure and satisfaction that I published new videos about Common Lisp data structures on my course.

The content is divided into 9 videos, for a total of 90 minutes, plus exercises, and comprehensive lisp snippets for each video so you can practice right away.

The total learning material on my course now accounts for 8.40 hours, in 10 chapters and 61 videos, plus extras. You get to learn all the essentials to be an efficient (Common Lisp) developer: CLOS made easy, macros, error and condition handling, iteration, all about functions, working with projects, etc. All the videos have english subtitles.

Table of Contents

What is this course anyways?

Hey, first look at what others say about it!

[My employees] said you do a better job of teaching than Peter Seibel.

ebbzry, CEO of VedaInc, August 2025 on Discord. O_o

🔥 :D

I have done some preliminary Common Lisp exploration prior to this course but had a lot of questions regarding practical use and development workflows. This course was amazing for this! I learned a lot of useful techniques for actually writing the code in Emacs, as well as conversational explanations of concepts that had previously confused me in text-heavy resources. Please keep up the good work and continue with this line of topics, it is well worth the price!

@Preston, October of 2024 <3

Now another feedback is that also according to learners, the areas I could improve are: give more practice activities, make the videos more engaging.

I worked on both. With the experience and my efforts, my flow should be more engaging. My videos always have on-screen annotations about what I’m doing or have complementary information. They are edited to be dynamic.

You have 9 freely-available videos in the course so you can judge by yourself (before leaving an angry comment ;) ). Also be aware that the course is not for total beginners in a “lisp” language. We see the basics (evaluation model, syntax…), but quickly. Then we dive in “the Common Lisp way”.

I also created more practice activities. For this chapter on data structures, each video comes with its usual set of extensive lisp snippets to practice (for example, I give you a lisp file with all sequence functions, showing their common use and some gotchas), plus 3 exercises, heavily annotated. Given the time of the year we are on, I prepare you for Advent Of Code :) I drive you into how you can put your knowledge in use to solve its puzzles. If you have access to the course and you are somewhat advanced, look at the new exercise of section 6.

Enough talk, what will you learn?

Course outcome

The goals were:

  • give you an overview of the available data structures in Common Lisp (lists and the cons cell, arrays, hash-tables, with a mention of trees an sets)
  • teach you how things work, don’t read everything for you. I show you the usual sequence functions, but I don’t spend an hour listing all of them. Instead I give you pointers to a reference and a lisp file with all of them.
  • give pointers on where is Common Lisp different and where is Common Lisp similar to any other language. For example, we discuss the time complexity of list operations vs. arrays.
  • teach common errors, such as using '(1 2 3) with a quote instead of the list constructor function, and how this can lead to subtle bugs.
  • make your life easier: working with bare-bones hash-tables is too awkward for my taste, and was specially annoying as a beginner. I give you workarounds, in pure CL and with third-party libraries.
    • 🆓 this video is free for everybody, hell yes, this was really annoying to me.
  • present the ecosystem and discuss style: for example I point you to purely-functional data-structures libraries, we see how to deal with functions being destructive or not destructive and how to organize your functions accordingly.

So, suppose you followed this chapter, the one about functions, and a couple videos on iteration: you are ready to write efficient solutions to Advent Of Code.

Chapter content

3.1 Intro [🆓 FREE FOR ALL]

Common Lisp has more than lists: hash-tables (aka dictionaries), arrays, as well as sets and tree operations. Linked lists are made of “CONS” cells. You should adopt a functional style in your own functions, and avoid the built-ins that mutate data. We see how, and I give you more pointers for modern Common Lisp.

3.2 Lists: create lists, plists, alists

What we see: how to create lists (proper lists, plists and alists). A first warning about the ‘(1 2 3) notation with a quote.

  • PRACTICE: list creation

3.3 Lists (2): lists manipulation

Lists, continued. What we see: how to access elements: FIRST, REST, LAST, NTH…

3.4 Equality - working with strings gotcha

What we see: explanation of the different equality functions and why knowing this is necessary when working with strings. EQ, EQL, EQUAL, EQUALP (and STRING= et all) explained. Which is too low-level, which you’ll use most often.

  • PRACTICE: using equality predicates.

3.5 Vectors and arrays

What we see: vectors (one-dimensional arrays), multi-dimensional arrays, VECTOR-PUSH[-EXTEND], the fill-pointer, adjustable arrays, AREF, VECTOR-POP, COERCE, iteration across arrays (LOOP, MAP).

  • EXERCISE: compare lists and vectors access time.

3.6 The CONS cell

A “CONS cell” is the building block of Common Lisp’s (linked) lists. What do “cons”, “car” and “cdr” even mean?

3.7 The :test and :keys arguments

All CL built-in functions accept a :TEST and :KEY argument. They are great. What we see: when and how to use them, when working with strings and with compound objects (lists of lists, lists of structs, etc).

3.8 Hash-tables and fixing their two ergonomic flaws [🆓 FREE FOR ALL]

Hash-tables (dictionaries, hash maps etc) are efficient key-value stores. However, as a newcomer, I had them in gripe. They were not easy enough to work with. I show you everything that’s needed to work with hash-tables, and my best solution for better ergonomics.

  • PRACTICE: the video snippet to create hash-tables, access and set content, use Alexandria, Serapeum’s dict notation, iterate on keys and values, serialize a HT to a file and read its content back.

3.9 Using QUOTE to create lists is NOT THE SAME as using the LIST function. Gotchas and solution.

Thinking that ‘(1 2 3) is the same as (list 1 2 3) is a rookie mistake and can lead to subtle bugs. Demo, explanations and simple rule to follow.

At last, EXERCISE of section 6: real Advent Of Code puzzle.

;;;
;;; In this exercise, we use:
;;;
;;; top-level variables
;;; functions
;;; recursivity
;;; &aux in a lambda list
;;; CASE
;;; return-from
;;; &key arguments
;;; complex numbers
;;; hash-tables
;;; the DICT notation (optional)
;;; LOOPing on a list and on strings
;;; equality
;;; characters literal notation

(defparameter *input* "....#.....
.........#
..........
..#.......
.......#..
..........
.#..^.....
........#.
#.........
......#...")

Closing words

Thanks for your support, thanks to everybody who took the course or who shared it, and for your encouragements.

If you wonder why I create a paid course and you regret it isn’t totally free (my past me would def wonder), see some details on the previous announce. The short answer is: I also contribute free resources.

Keep lisping and see you around: improving the Cookbook or Lem, on the Fediverse, reddit and Discord…

What should be next: how the Cookbook PDF quality was greatly improved thanks to Typst. Stay tuned.

Oh, a last shameless plug: since Ari asked me at the beginning of the year, I now do 1-1 Lisp coaching sessions. We settled on 40 USD an hour. Drop me an email! (concatenate 'string "vindarel" "@" "mailz" "." "org").

🎥 Common Lisp course in videos

🕊