Lisp is a functional programming language where the basic data structure is linked lists and atoms. It was one of the earliest programming languages developed in 1958. Lisp programs are run by interacting with an interpreter like Clisp. Key aspects of Lisp include its use of prefix notation, treating all code as nested lists, defining functions using defun, and its emphasis on recursion and higher-order functions. Common control structures include cond for conditional evaluation and looping constructs like loop. Lisp fell out of widespread use due to performance issues with interpretation and low interoperability with other languages.

1. LISP
Lisp Programming Language

2. LISP
What is LISP?
• A LISt Processing language
– The basic data structure is linked list and Atoms.
• A functional programming language
– Each expression in LISP is a function that returns a value
• An interpretive language
– Running LISP programs involves interacting with the LISP
interpreter.
– Clisp is the common lisp interpreter available only for Linux.
– Recently Compilers have been made for this language but
they are not used a lot.

3. LISP
History
• First developed by John McCarthy as a language for symbolic
(rather than numeric) computation in 1958 based on Fortran
Syntax
• Very SLOW:
– no compilation of source to machine code
– inefficient garbage collector
• Historical Reason
– Most AI programs in the U.S. have been developed in LISP
– However, most AI programs in Europe have been developed
in PROLOG

4. LISP
Terminology
•Write a program => Define a set of
functions
•Running a program => Evaluating an
expression
•Simple syntax: operator precedence issues
eliminated
•Lists (or S-expressions) are important:
•Functions are defined as lists
•Lists can be manipulated easily in Lisp
•Functions can be manipulated easily

5. LISP
Functions
• Lisp is a functional language – So everything is a function
-> Functions in other languages
var sum := sqrt(x)
Print sum
In lisp this function is:
-> (sqrt x)
• Most LISP functions require you to think and use Prefix
Notation – you have to think backwards
– (print (+ 5 (sqrt 6)))
• And there are primary effects and side effects
– In ‘pure’ Lisp, we ONLY get values by executing a function.
– We DON’T set a variable to a new value INSIDE a function….that is a
side effect of executing a function. (You all probably do that all the
time in Java or C++)

6. LISP
How the Lisp Functions work –
The read-eval loop
• Evaluation process starts with an “S”
expression (i.e., a function and operands to
that function) This one adds two numbers….
(+ 3 4)
Parentheses – Notification to evaluate
Function name – Go get function (in this case ‘+’ is
the add function)
space - separator
operands -- value for function
Parentheses – stop evaluation and return the
answer

7. LISP
How Lisp Interpreter Works
•Programs are lisp objects (i.e.
functions)
•Evaluation of a lisp object returns a
new object.
•Evaluation is simply a function called
EVAL that maps lisp objects to lisp
objects:
•EVAL: object => object
•we will use the symbol => to
represent evaluation
•The Lisp interpreter is a loop
consisting of:
•read a lisp expression

8. LISP
Let’s start with the math
functions
• There are many built in arithmetic functions
• You then put these arithmetic functions
together

9. LISP
Arithmetic Functions
(+ numbers…) -- adding
(- numbers…) -- subtracting
(* numbers…) -- multiplication
(/ numbers…) -- division
(1+ number) – plus 1 (this is hard to read)
(1- number) – minus 1
(abs number) etc…..
(acos number)

10. LISP
Examples:

11. LISP
Atoms
• Atoms:
– Number
» examples: 3, 8.9, etc.
– Symbol
» An object written as a sequence of characters
» Symbols are usually manipulated as names that
are “bound” to other lisp objects
• Symbol FOO might be bound to 4.2

12. LISP
Lists
•Lists :
•Anything with parentheses
around it.
•()
•(a)
•(this is one too)
•(a list of (two) lists)
•(a (very (very (very
(inscrutable) list)))

13. LISP
A Special Symbol: NIL
• NIL represents an empty list.
• NIL is a terminator of a list.
• A list is usually built by inserting its elements
into NIL in the reverse order .
• NIL can also represent “false''.
• The special symbol representing “true” is T.

14. LISP
Taking lists apart
• (first <a list>) returns the first element of the
list.
• (rest <a list>) returns the remaining list (i.e.,
everything except the first element).

15. LISP
Quote
• Quote symbol ‘ is a short hand for the
function called QUOTE.
• (QUOTE <arg>)
• QUOTE is a special function that prevents
LISP from evaluating its argument.
• QUOTE returns the argument literately.
Example: (quote (dummy-fn 2))
==> (DUMMY-FN 2)

16. LISP
Basic Evaluation Rules
• A number evaluates to itself
• A symbol evaluates to its value.
• A list is evaluated by
– treating the first element as a function
– evaluating each arguments of the function in a left-to-right
order
• An expression preceded by a quote symbol ‘
evaluates to the expression itself.

17. LISP
Assignment and Binding
• A symbol (or variable) can be assigned a
value (called its binding) using SETQ.
• (SETQ <symbol-name> <anything>)
Example: (SETQ A ‘(A B C)) ==> (A B C)
A evaluates to ==> (A B C)
• Evaluating a symbol that does not have a
value assigned (i.e., no binding) causes error

18. LISP
All other functions do NOT
change the bindings
• In particular, FIRST and REST are non-
destructive.
> (setq my-friends ‘(Superman Batman Robin) )
(Superman Batman Robin)
> (first (rest my-friends))
Batman
> my-friends
(Superman Batman Robin)

19. LISP
Defining My-Own Functions
• A function is defined using DEFUN
• (DEFUN <fn-name> (<arg1> ...<argK>)
<exp1> ... <expN> )
• All arguments are passed by value.
• The body of the function may contain any
number of expressions (i.e., function calls).
• The function returns the value returned by the
last expression.

20. LISP
Defining A Function
(defun square (x)
(times x x) )
(defun add-friend (new-friend friends)
(cons new-friend friends) )

21. LISP
Predicates – Checking to see if
something is true….
• Functions that return ``true’’ (i.e., T) or
``false’’ (i.e., NIL).
type-testing predicates
• (NULL <item>) returns T if <item> is NIL
(empty list), otherwise NIL.
• (LISTP <item>) returns T if <item> is a list,
otherwise NIL.
• (ATOM <item>) returns T if <item> is an atom
(i.e., a symbol, a number, or NIL).
• (NUMBERP <item>) returns T if <item> is a
number

22. LISP
Conditional Expression
• COND is an N-branch conditional expression
(COND ( <test1> <exp11> ... <exp1L> )
( <test2> <exp21> ... <exp2M> )
...
( <testK> <expK1> ... <expKN> ) )
• Each test is evaluated sequentially until a test
returns true.
• Expressions following that test will be
executed.
• COND returns the value returned by the last
expression associated with the test.

23. LISP
Terminates a COND with a T
condition
(defun select-character (enemy)
(cond ( (equal enemy ‘Penguin)
‘Batman)
( (equal enemy ‘Catwoman)
‘J-Bond )
( (equal enemy ‘Black-Knight)
‘(White-Knight King-Arthur ) )
( T ; for all other enemies
‘SuperMan) ; ask Superman for help
)
)

24. LISP
Using AND, OR in COND
(defun Evaluate-feeling ( sentence )
(cond ( (OR (member ‘hate sentence)
(member ‘dislike sentence))
‘hatred)
( (AND (member ‘I sentence)
(member ‘feel sentence) )
‘self-centered )
( T
‘happy)
) ; end of cond
) ; end of defun

25. LISP
Loops
i=1, while i <= 3:
=> (loop for i in ‘(1 2 3) do (print i))
1 2 3
i=1, while i <= 3: (different step)
=> (loop for i from 1.0 to 3.0 by 0.5 do
(print i))
i=3, while i >= 1:
=> (loop for i from 3 downto 1 do (print i))
3
2
1

26. LISP
Conclusion
Things to remember:
•Lisp is considered the mother of a lot of
functional languages like Scheme and Haskell …..
•Common Lisp has dynamic type checking
•Lisp is interpreted.
The reason why Lisp is dead:
•Stock hardware platforms becoming faster than
special purpose hardware
•Low Interoperability with other languages