Introduction/Lisp Review

1. Prep:

A. Handouts, 3x5's out.

B. Course, Name, Survey on Board
(Name, SSN, Employer, Day Phone, Instructor for 723, A*/IDA*/NLP knowledge, interests)

2. Texts:

A. Steele previously required. But available now via WWW
http://www.apl.jhu.edu/~hall/lisp.html (Check this often!)

B. CLtR available on-line (clman from UNIX, M-m or M-x clman from emacs)

C. Some Lisp Tutorial (or notes).

D. Norvig optional but excellent. (Will not cover explicitly in class).

E. For others, see handout on Lisp References.

3. Computer Accounts

A. Apply Today (during break). Can work on other machines but get account anyhow. See WWW page above for free CL for UNIX, VMS, DOS, or Windows.

B. Emacs (See handouts)

C. Prefer Email

D. ~hall/class/Set-Up-Account - optional but highly recommended.

4. Expectations

A. .723 or equivalent.

B. AI: Search, trees, A*, Production Rules, NLP

C. Lisp: Quoting/evaluation, defun, passing functions, recursion, everything on handout (will review today).

5. Structure

A. AI Topics/Lisp Topics split.

B. Weighted HW's

C. No exams

D. Questions strongly encouraged in class (but don't dominate)

6. Grading

A. Weighted HW's only. No exams. No curve. No objection to all A's (or all C's).

B. A+ = 4.1
A = 4.0
A- = 3.7
B+ = 3.3
etc. (0.3 for +/-)

C. Factors:

i. Correctness

ii. Quality of Code (Defined more throughout semester)

D. Ethics:
i. Copying: Do not look at other people's code (discussion only)

ii. Code in Texts: Reference it, explain it extra thoroughly, preferably rewrite some.

7. Why Lisp?

A. Dominant language of AI (Begs question, but compare C/UNIX for general CS)

B. Abstractions (High Level Datatypes, Functional Programming)

C. Functions as First-Class Objects (Higher-Order functions, applicative programming)

D. Recursion

E. Object-Oriented Programming

F. Macros (program generation facility, syntax extender)

8. Whirlwind Lisp Review (Roughly follows 1 page handout)

A. Datatypes: atoms and lists
Atom --> String | Symbol | Number | .,. (hash tables, etc.)
String --> "" | "Foo" | ...
Number --> 1 | 1.23 | 1.23E-45 | #o12 [ten in octal] | #c(2 3) [2 + 3i] | ...
Symbol --> pi | Even? | cons | X | Normalize-Array-Entries | ...
List --> ( Atoms-or-Lists )
Atoms-or-Lists --> Atom | List | Atoms-or-Lists Atoms-or-Lists

B. Evaluation

i. Strings/Numbers: Themselves

ii. Symbols: Value of variable

iii. Lists: First entry is a function name, to be applied to evaluated arguments

iv. Exception: QUOTE, SETQ [If *goal* is side-effect, then it is an exception. But you don't usually get fooled]

C. Examples with numbers: *, +, -, /

D. Style: Indentation is important. Compare the following (on handout):

Point: removing most of the parens and leaving correct indentation is much more readable than leaving the parens and having wrong indentation.

Putting close parens on their own line is poor style in Lisp. Reason: in procedural languages, begin/end of a procedure is important thing. In Lisp, you have composition of functions, so nesting level is most important thing, and indentation gives that visual cue.

E. Defun:
SQUARE, AT-RANDOM, ADD-3
functional style, avoid globals, read re "let/let*"

F. List Functions

i. Construction: quote, list, cons, append

ii. Access: first, second, ... , tenth, last, rest, nth, subseq, butlast, etc.

G. Recursion
i. Solve Easy (Base) Case

ii. [Magic] Assume it works for some arbitrary size (call this N-1)

iii. Show how to solve size N problem, given function works on size N-1 or smaller
Factorial, Last-Element, Every-Other, Length-Of

H. loop [replaces dotimes/dolist/do]. See handout.

           (loop for I from 1 to 5 do (print I))
           (loop for I in '(A B C D)) do (print I))

           (loop for I from 1 to 9 by 2 do (print I) finally (return I))

I. Function Application (PROBABLY WON'T COVER MUCH EXCEPT MAPCAR)
Running example: ((Name Course-Num Grade) ...)
i. mapcar [All names (remove-duplicates)]

ii. apply [Add all grades]

iii. funcall

iv. find [find first C via below 80]

v. find-if [same thing]

Table of contents

1. - Prep:

2. - Texts:

3. - Computer Accounts

4. - Expectations

5. - Structure

6. - Grading

7. - Why Lisp?

8. - Whirlwind Lisp Review (Roughly follows 1 page handout)