You're kind of in luck. For a while, it was trendy (because MIT was doing it) to teach Intro to Programming with Lisps, especially Scheme. Because of this, there are quite a few "learn programming with Lisp" books and resources. The famous "SICP" book was the textbook for the MIT course and all of the examples were Lisp (there's a newer version that uses JavaScript, I think). There are loads of fine online books and guides. Here's a random online book: https://gigamonkeys.com/book/

In no time you'll be putting up "my other car is a cdr" bumper stickers!

> In no time you'll be putting up "my other car is a cdr" bumper stickers!

Yeah but then learning Lisp is going to get in the way of welding up new bumper brackets, and the bumper will still be lying in the pile of things beside the shed waiting to be reattached... ;-)

The MDL bumper sticker, "my other 1 is a REST", just doesn't have the same ring to it.

Everyone's recommending books; I'm going to do the opposite and recommend a specific dialect.

Install Clojure. Read https://clojure.org/guides/getting_started and choose an editor. If you don't have a favorite editor, I recommend NeoVim with the LazyVim package (clone https://github.com/LazyVim/starter and follow instructions), then run the :LazyExtras command and install the Clojure package. If you haven't used LazyVim before, https://lazyvim-ambitious-devs.phillips.codes/ is a good book; you can read it online for free, then if you find it useful, purchase a copy to reward the author for his hard work.

Once you've installed an editor, you'll want to install https://leiningen.org/ which is the de facto (if not de jure) package manager for Clojure. Makes compiling your Clojure code to an .exe (for distribution to other machines where Clojure isn't installed) about as simple as it can be.

Once you've got an editor and a package manager installed, you're ready to read https://clojure.org/guides/learn/clojure as well as the various books on Lisp others are recommending. Depending on which book it is, the functions may have different names (e.g., some languages use `first` and `rest` while others stick with the historical `car` and `cdr` names, but they're the same functions), but you should find that the concepts translate perfectly well from one dialect of Lisp to another and the only challenge is having to look up what name the function has in the dialect you're using.

I should mention that you really do want good editor support with any dialect of Lisp, because having to balance parentheses by hand gets old fast. You want an editor where you can have keybindings for "pull this space-delimited item out of the current parentheses and stick it into the parent set of parentheses" and all the other operations that are extremely common in Lisp. Also, smart auto-indenting is absolutely essential in order to produce readable Lisp code. You need things lined up correctly if you want to be able to read the code without resorting to counting closing parens. This is why so many people use Emacs, because it was designed for Lisp from the ground up. But I never liked its Ctrl+Shift+Meta+key shortcut methods, hence why I'm recommending Vim.

Emacs does have one advantage over Vim when it comes to Lisp, though, which is that it almost certainly comes with Lisp-related keybindings already ready to go. And also that its config files are written in Lisp, so if you're using Emacs then you're already reading and writing Lisp code just to configure it. Two. Two advantages. Oh, and fanatical devotion to the Pope ^W^W Richard Stallman. Three advantages... I'll come in again.

I suggest: A Gentle Introduction to Symbolic Computation

https://www.cs.cmu.edu/~dst/LispBook/book.pdf

In Grad School I started with an "AI in Lisp Textbook" (which was still the most common at the time in the late oughts, I hear many have moved to Python since) and searched for a Common Lisp interpreter that felt right. I think I ended up with SBCL [0], but this was obviously a while back so my memory is slippery about it.

(The professor I had for that AI course in Grad School didn't know Lisp and wanted to learn it better, especially because so much of the textbook was in it, so asked us for volunteers to learn it as well and I took that as an excuse/challenge to do every project with a language choice that semester in Common Lisp.)

[0] https://www.sbcl.org/

The summer before i took 6.001 i read “The little LISPer”. It is a good intro.

This is the version i read:

https://www.abebooks.com/9780023397639/Little-LISPer-Third-E...

The first step is to overcome the syntax. It's useful to think in terms of Python syntax at first.

  f(x)
  (f x)
  ["f", "x"]

  (print (< 10 20))
  ["print", ["<", 10, 20]]

Lisp code is just list data which gets evaluated by an interpreter function. Like this:

  code = ["print", ["<", 10, 20]]

  def eval(code):
    # magic

  eval(code)  # True

Filling out that eval function is a great way to learn. I only truly understood lisp when I implemented my own.

These articles are very good and accessible:

https://www.norvig.com/lispy.html

https://norvig.com/lispy2.html

Funny you mention this, as I've written quite a bit of Python code that works just like this, typically in the form of an evaluator for some random proprietary language I've parsed into an AST in the form of a Python list or tuple.

With lisp? Honestly I'd start by installing emacs and messing with elisp. It comes with a beginners guide to elisp with the docs iirc

Start with SICP!