LISP stands for LISt Processing and was invented by John McCarthy, who was looking computation with symbols and recursive functions in the 1960s.

John McCarthy was the son of immigrant Communists (members of the CPUSA), but after witnessing the failed counter-revolution in Prague in 1968, he himself became a Republican .

A Lisp program consist of a few basic building blocks:

• Symbols - basically text without whitespace, for example: +, hello123, if, nil, etc.
• Numbers, Strings, etc.
• Cons cells - a Pair, denoted as (cons 1 2) or dotted (1 . 2)
• Lists - a linked list of Cons cells with the final element being the symbol nil.
  • (list 1 2 3) is the same as (1 . (2 . (3 . nil))).

As you may have noticed, cons and list are inside the parentheses, thats because a function call like f(x,y) is written instead as (f x y). This is called a Symbolic expression and all Lisp code looks like this.

(+ 1 (* 2 3) 4)
;; multiply 2 times 3 => (+ 1 6 4)
;; add 1 6 and 4      => 11

;; the names 'car' and 'cdr' are ancient relics from some assembly instructions
;; basically first and second element of a cons cell
;; or head and tail of a list
(car (cons 1 2)) ;; => 1
(cdr (cons 1 2)) ;; => 2

This in turn means that any code can be turned into a list, so that it can be modified like data. I think thats quite neat and unique among programming languages (it even has a fancy word: this property is called homoiconicity).

Functions that operate on code are called macros.

;; generate a function 'name' that adds 'value' to the input
(defmacro defun-adder (name value) 
  (list 'defun name (list 'x) (list '+ 'x value)))
 
(defun-adder plus5 5)
;; define the function plus5(x) as x + 5 
;; => (defun plus5 (x) (+ x 5)))

(plus5 10) ;; => 15

To make sure the interpreter does not try to evaluate a symbol, it needs to be "quoted". Since this comes up quite often, it gets the shortcut of ' at the beginning.

Theyre much nicer to work with than for example macros in C:

#define PI 3.14159265

this C macro just searches and replaces the string PI in the C source code before compilation and theres lots of ways to mess up, for example

#define DOUBLE(x) x + x

if x is a function call that does something else, like printing, then that message will appear twice. Operator prescedence is also not considered: DOUBLE(1) * 3 will expand to 1 + 1 * 3, so 4 not 6 like one would expect.

The last thing I want to yap about is Lisp1 vs Lisp2. This refers to the amount of namespaces any programming language has. if functions and variables are allowed have same names, then there needs to be a namespace for each.

for example in CL:

(defvar x 1)
(defun x () (+ 1 1))

x   ;; variable      => 1
(x) ;; function call => 2

is perfectly fine, while in other languages like Python or C or Scheme this wouldnt work.

Shoutout to respected comrades lilypad and sodium_nitride who are also true Lisp patriots.