Presentation is loading. Please wait.

Presentation is loading. Please wait.

CS 63 LISP Philip Greenspun's Tenth* Rule of Programming: "Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified bug-ridden.

Similar presentations


Presentation on theme: "CS 63 LISP Philip Greenspun's Tenth* Rule of Programming: "Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified bug-ridden."— Presentation transcript:

1 CS 63 LISP Philip Greenspun's Tenth* Rule of Programming: "Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified bug-ridden slow implementation of half of Common Lisp. * Note: there arent actually nine other rules, just the tenth one.

2 Something I stumbled across… …teaching Lisp by showing you how to write several complete Lisp-based games, including a text adventure, an evolution simulation, and a robot battle. Disclaimer: Im not endorsing this book, I just liked the cover.

3 Why Lisp? Because its the most widely used AI programming language Because its good for writing production software (Graham article) Because its got lots of features other languages dont Because you can write new programs and extend old programs really, really quickly in Lisp

4 Great! How can I get started? Run /usr/bin/clisp From you can download CLISP for your own PC (Windows or Linux)http://clisp.cons.org Great Lisp resource page:

5 Why all those parentheses? Surprisingly readable if you indent properly (use built-in Lisp editor in emacs!) Makes prefix notation manageable An expression is an expression is an expression, whether its inside another one or not (+ 1 2) (* (+ 1 2) 3) (list (* 3 5) atom (list inside a list) (list 3 4) (((very) (very) (very) (nested list))))

6 Lisp basics Lisp syntax: parenthesized prefix notation Lisp interpreter: read-eval-print loop Nested evaluation Preventing evaluation ( quote and other special forms) Forcing evaluation ( eval ) –Allows us to evaluate code contained in a Lisp variable!

7 Basic Lisp types Numbers (integers, floating-point, complex) – Characters, strings (arrays of chars) –#\x #\- #\B –This is a string! Symbols, which have property lists –a x jon Lists (linked cells) –Empty list: nil –(a b c) (2 3 jon) –cons structure has car (first) and cdr (rest)

8 Built-in functions For numbers –+ - * / incf decf A diversion: destructive functions –(setf x 1) –(setf y (+ x 1)) vs. (setf y (incf x)) For lists –car (first) cdr (rest) second third fourth –length nth –cons append nconc list –mapcar mapcan –find remove remove-if

9 Built-in functions (contd) Printing: print, format –(print string) print output –(format …) formatted output Advanced list processing: assoc, mapcar Predicates: listp, numberp, stringp, atom, null, equal, eql, and, or, not Special forms: setq/setf, quote, defun, defparameter, defconstant, if, cond, case, progn, loop

10 More Lisp types Arrays (with zero or more dimensions) Hash tables Streams (for reading and writing) Structures Functions, including lambda functions –(defun incBy10 (n) (+ n 10)) –(mapcar #(lambda (n) (+ n 10)) ( ))

11 Useful help facilities (apropos str) list of symbols whose name contains str (describe symbol) description of symbol (describe #fn) description of function (trace fn) print a trace of fn as it runs :a abort one level out of debugger

12 A Lisp example Writing a function to compute the nth Fibonacci number –Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, … fib(0) = 0 fib(1) = 1 fib(n) = fib(n-2) + fib(n-1)

13 Complete Version (defun fib (n) (cond ((eql n 0) 0) ; base case ((eql n 1) 1) ; base case (t (+ (fib (- n 1)) ; recursively compute fib(n) (fib (- n 2))))))

14 Complete Version with Error Checking and Comments (defun fib (n) "Computes the nth Fibonacci number." (cond ((or (not (integerp n)) (< n 0)) ; error case (error "~s must be an integer >= 0.~&" n)) ((eql n 0) 0) ; base case ((eql n 1) 1) ; base case (t (+ (fib (- n 1)) ; recursively compute fib(n) (fib (- n 2))))))

15 Now youve been enlightened! …well, sort of… Cartoon from xkcd.com


Download ppt "CS 63 LISP Philip Greenspun's Tenth* Rule of Programming: "Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified bug-ridden."

Similar presentations


Ads by Google