IMPORTANT: Depending on how you learn, you may find that starting with Chapter 2
from Paul Graham's book 

https://web.archive.org/web/20220309091553/http://ep.yimg.com/ty/cdn/paulgraham/acl2.txt

makes _infinitely_ more sense for you that starting with the textbooks's Chapter 3---or vice
versa. Try it and see! Then calibrate accordingly.

For me, I noticed again and again that I absolutely hated some textbooks or programming
environments and loved others, often for no apparent reason. This is why I try to give
a lot of different links.

As I aged, some of these things started to make sense to me, but others still don't :)
I am sure of one thing: learning styles may differ a lot, and one's neural makeup is
an ever-present factor, although hard to quantify the effects of.

----------------------------[ LISP ]----------------------------

Chapter 3 in the Mitchell textbook covers LISP. Sections 3.1--2 cover LISP's
history, but it should be noted that LISP lives on many shapes, including
the programmable Emacs editor (see below). Sections 3.3 and 3.4 give an
overview of the language. You may skip the pieces about Scheme, we'll revisit
them later. 

Pay special attention to the abstract machine of CONS cells described in 3.4.3
and use the exercises in it to check yourself. Also pay special attention to 3.4.4
(programs as the fundamental data type, the list of cons cells) and 3.4.6
(recursion on the object's intended structure, also tied to cons cells).

The idea that functions should use no loops or other iterators (such as
pointers or references external to the data objects), but should rather
use recursion over the object's own natural structure is very powerful, and
drives modern languages such as Haskell and Rust, in the guise of "pattern matching"
style of coding (i.e., matching the object's structure).

After you absorb this idea, the code that works on complex objects "practically
writes itself". Moreover, this style drives you to think about the corner cases,
such as getting atoms where you expect lists (i.e, a cons cell). Once noted, this
developed into type-driven programming (Idris, Agda, etc.) 

Writing code that recurses on the object's own structure should become your
second nature. Practice, practice, practice: go through the examples in
Paul Graham's Chapter 2 of "ANSI Common LISP", linked from https://paulgraham.com/acl.html
(forwards to https://sep.turbifycdn.com/ty/cdn/paulgraham/acl2.txt?t=1688221954& . The
above Archive.org link is also good.)

This book is, unfortunately, not free, but Chapters 1 and 2 are online, and
are very useful.

Paul Graham has a free book, http://www.paulgraham.com/onlisptext.html .
You may want to read sections 2.1--2.3. Have your LISP shell open, and try every
command; this is the only way. 

There's another free book on LISP, http://www.gigamonkeys.com/book/
Give it a try; Chapters 1--6 cover a lot of ground.

==========================[ Emacs ]=====================================

One of the best ways to experience LISP is through the Emacs text editor. Emacs is an
all-time classic of software in many senses of the word, still unbeaten in most of these
senses (if you ask me; for someone else's perspective, see [2]). It is powered by a
dialect of LISP called eLISP. You can get a quick-and-dirty introduction to eLISP from
[3] or [4].

You can install emacs on MacOS following https://wikemacs.org/wiki/Installing_Emacs_on_OS_X
or https://ports.macports.org/port/emacs/

A one-page cheat-sheet for Emacs I handed out in class:
https://sachachua.com/blog/wp-content/uploads/2013/05/How-to-Learn-Emacs-v2-Large.png 

A tour of Emacs is at https://www.gnu.org/software/emacs/tour/index.html

My old note on running LISP in Emacs:
https://www.cs.dartmouth.edu/~sergey/cs59/lisp/running-lisp-in-emacs.txt

[2] https://hackernoon.com/8-reasons-why-emacs-is-the-best-text-editor-for-programming-0w4o37ld

[3] https://steve-yegge.blogspot.com/2008/01/emergency-elisp.html

[4] https://github.com/chrisdone-archive/elisp-guide