page 2: “Lisp encourages good programming practices like how there’s always a single return statement from a function …”

return-from but if you don’t use that there’s exactly 0 return statements, and the only “statements” in CL ever are in tagbody/prog

“… and how all data that you work with is immutable unless you really need to change it otherwise”

everything is mutable except for numbers, though it is less hellish than usual to just ignore mutability and only use not-mutating functions, but someone else can go mutate so you’re not safe

page 7: “Lisp is not a type-safe language like C, C++, and the likes”

I’m sorry I can’t hear you over (void*)

“No programming language is complete without having types that can store numbers.”

…we can do Church encoding in a later decade

“For boolean, Lisp follows a very similar approach as JavaScript, which is technically an offspring of the former.”

AAAAAAAAAAAAAAaaaaaaaaaa

“Everything that is not null is treated as true.”

holy shit we’re going to get not one but two programming languages wrong in this book, here are the falsy values in JavaScript https://developer.mozilla.org/en-US/docs/Glossary/Falsy

page 8: “Everything in Lisp is a list”

no, absolutely not, what are atoms

page 9: “So now, it can be written as either of the following:”

(cons Shephard (cons Joker nil))

OR

(Shepard . (Joker . nil))

those are not the same list, and the former will not evaluate to the latter without binding shephard and joker appropriately

(funnily enough the author recommends Land of Lisp which makes the same mistake modulo quoting on page 40)

page 11: “all of the following four values are treated as false:

nil: which by default is false”

what is the non-default value of nil, pray tell

“2. 'nil: which is a symbol that points to the value nil (which is false)”

that is a list of the symbols named quote and nil

“3. '(): which is an empty list”

ditto

“4. (): which is an empty form (no function with no arguments)

This enables us to write our code without having to worry about null conditions as you would need to in other programming languages that do not have this feature.”

what

pages 19-20: “However, the major difference here is that the function [defined by lambda] does not have a name anymore, and can be treated as a regular value.”

but you use a function defined by defun as a value in literally the next paragraph

page 27: “You can also sort a sequence in a specified way:

(sort '(3 2 1) #'>)“

are we going for the UB% speedrun

page 34: “Advanced data-structures

Lisp also has several other data-structures, most of which we use in other programming languages. Some of these are arrays, hash-tables, structures, etc. I have decided to keep them out of the scope as that is not the focus for us.”

oh for fuck’s sake we’re never beating the “no other aggregate data structure” allegations

page 55: “An interpreter is a software tool that executes source code directly, translating it into machine code or an intermediate representation line-by-line or statement-by-statement, without producing a separate executable file. It processes and runs code in real-time.”

Lisp invented the interactive compiler [citation needed], WHY WOULD YOU WRITE THE LAST PART

in conclusion I will raise my children^Wstudents to be Smalltalk weeenies