Section 10: LISP to Scheme. Evolution of Software Languages

Save this PDF as:
 WORD  PNG  TXT  JPG

Size: px
Start display at page:

Download "Section 10: LISP to Scheme. Evolution of Software Languages"

Transcription

1 Section Evolution of Software Languages Theo D'Hondt Bachelor of Computer Science Faculty of Sciences and Bio-Engineering Sciences Vrije Universiteit Brussel Academic Year Evolution of Software Languages 1

2 John McCarthy john-mccarthy-computer-scientist-known-as-thefather-of-ai html Father of LISP Credited with term "AI" Built on the IBM 604/9 Originated at MIT and at Stanford Survives in Common Lisp Gave rise to Scheme First "functional" language Evolution of Software Languages 2

3 John McCarthy john-mccarthy-computer-scientist-known-as-thefather-of-ai html Lispers say these are LISP... Arc, AutoLISP, Father Clojure, of LISP Common Lisp, Emacs Credited Lisp, EuLisp, with term Franz "AI" Lisp, Hy, Interlisp, Built on ISLISP, the IBM LeLisp, 604/9 LFE, Maclisp, Originated MDL, Newlisp, at MIT NIL, and at Picolisp, Portable Stanford Standard Lisp, Racket, RPL, Survives Scheme, in Common SKILL, Lisp Spice Lisp, Gave T, rise Zetalisp to Scheme First "functional" language Evolution of Software Languages 3

4 LISP I Programmer's Manual (March 1960) Define a function collapse: given some implementation for a function append: Evolution of Software Languages 4

5 LISP I Programmer's Manual (March 1960) Define a function collapse: resulting in the input card deck given some implementation for a function append: Evolution of Software Languages 5

6 (pre-) Common Lisp S-expressions Functions as values Meta-circularity Quoting and eval Automatic garbage collection Full syntactic macros (later) CLOS and MOP Encourages imperative style Ambivalent view on functions/function values Ambivalent view on scoping No tail call optimisation No full continuations Evolution of Software Languages 6

7 (pre-) Common Lisp S-expressions Functions as values Meta-circularity Quoting and eval Automatic garbage collection Full syntactic macros (later) CLOS and MOP Encourages imperative style Ambivalent view on functions/function values Ambivalent view on scoping No tail call optimisation No full continuations Evolution of Software Languages 7

8 (pre-) Common Lisp S-expressions Functions as values Meta-circularity Quoting and eval Automatic garbage collection Full syntactic macros (later) CLOS and MOP Encourages imperative style Ambivalent view on functions/function values Ambivalent view on scoping No tail call optimisation No full continuations revolution/artificialintelligence-robotics/13/290/1254 Evolution of Software Languages 8

9 LISP example1 (defparameter *width* 100) (defparameter *height* 30) (defparameter *jungle* '( )) (defparameter *plant-energy* 80) (defparameter *plants* (make-hash-table :test #'equal)) (defun random-plant (left top width height) (let ((pos (cons (+ left (random width)) (+ top (random height))))) (setf (gethash pos *plants*) t))) (defun add-plants () (apply #'random-plant *jungle*) (random-plant 0 0 *width* *height*)) (defstruct animal x y energy dir genes) (defparameter *animals* (list (make-animal :x (ash *width* -1) :y (ash *height* -1) :energy 1000 :dir 0 :genes (loop repeat 8 collecting (1+ (random 10)))))) Evolution of Software Languages 9

10 LISP example2 (defun move (animal) (let ((dir (animal-dir animal)) (x (animal-x animal)) (y (animal-y animal))) (setf (animal-x animal) (mod (+ x (cond ((and (>= dir 2) (< dir 5)) 1) ((or (= dir 1) (= dir 5)) 0) (t -1)) *width*) *width*)) (setf (animal-y animal) (mod (+ y (cond ((and (>= dir 0) (< dir 3)) -1) ((and (>= dir 4) (< dir 7)) 1) (t 0)) *height*) *height*)) (decf (animal-energy animal)))) (defun turn (animal) (let ((x (random (apply #'+ (animal-genes animal))))) (labels ((angle (genes x) (let ((xnu (- x (car genes)))) (if (< xnu 0) 0 (1+ (angle (cdr genes) xnu)))))) (setf (animal-dir animal) (mod (+ (animal-dir animal) (angle (animal-genes animal) x)) 8))))) Evolution of Software Languages 10

11 LISP example3 (defun eat (animal) (let ((pos (cons (animal-x animal) (animal-y animal)))) (when (gethash pos *plants*) (incf (animal-energy animal) *plant-energy*) (remhash pos *plants*)))) (defparameter *reproduction-energy* 200) (defun reproduce (animal) (let ((e (animal-energy animal))) (when (>= e *reproduction-energy*) (setf (animal-energy animal) (ash e -1)) (let ((animal-nu (copy-structure animal)) (genes (copy-list (animal-genes animal))) (mutation (random 8))) (setf (nth mutation genes) (max 1 (+ (nth mutation genes) (random 3) -1))) (setf (animal-genes animal-nu) genes) (push animal-nu *animals*))))) Evolution of Software Languages 11

12 LISP example4 (defun update-world () (setf *animals* (remove-if (lambda (animal) (<= (animal-energy animal) 0)) *animals*)) (mapc (lambda (animal) (turn animal) (move animal) (eat animal) (reproduce animal)) *animals*) (add-plants)) (defun draw-world () (loop for y below *height* do (progn (fresh-line) (princ " ") (loop for x below *width* do (princ (cond ((some (lambda (animal) (and (= (animal-x animal) x) (= (animal-y animal) y))) *animals*) #\M) ((gethash (cons x y) *plants*) #\*) (t #\space)))) (princ " ")))) Evolution of Software Languages 12

13 LISP example5 (defun evolution () (draw-world) (fresh-line) (let ((str (read-line))) (cond ((equal str "quit") ()) (t (let ((x (parse-integer str :junk-allowed t))) (if x (loop for i below x do (update-world) if (zerop (mod i 1000)) do (princ #\.)) (update-world)) (evolution)))))) Evolution of Software Languages 13

14 Carl Hewitt Researcher at MIT Built "Planner" Defined "Actors" Hard to read papers Fathered ACT-1,... (Henry Lieberman) (PhD with Seymour Papert) Evolution of Software Languages 14

15 The Actor Model1 Evolution of Software Languages 15

16 The Actor Model2 (define p (act->scheme '((define counter (BEHAVIOR (value) (METHOD (up n) (BECOME counter (+ value n))) (METHOD (down n) (BECOME counter (- value n))) (METHOD (display) (display "value=") (display value) (newline)))) (define c1 (NEW counter 0)) (define c2 (NEW counter 5)) (SEND c2 down 2) (SEND c1 up 1) (SEND c2 up 5) (SEND c1 display) (SEND c2 display)))) (define act-p (eval p (interaction-environment))) (act-p)) Evolution of Software Languages 16

17 The Actor Model2 (define p (act->scheme '((define counter (BEHAVIOR (value) (METHOD (up n) (BECOME counter (+ value n))) (METHOD (down n) (BECOME counter (- value n))) (METHOD (display) (display "value=") (display value) (newline)))) (define c1 (NEW counter 0)) (define c2 (NEW counter 5)) (SEND c2 down 2) (SEND c1 up 1) (SEND c2 up 5) (SEND c1 display) (SEND c2 display)))) (define act-p (eval p (interaction-environment))) (act-p)) Evolution of Software Languages 17

18 The Actor Model2 (define p (act->scheme '((define counter (BEHAVIOR (value) (METHOD (up n) (BECOME counter (+ value n))) (METHOD (down n) (BECOME counter (- value n))) (METHOD (display) (display "value=") (display value) (newline)))) (define c1 (NEW counter 0)) (define c2 (NEW counter 5)) (SEND c2 down 2) (SEND c1 up 1) (SEND c2 up 5) (SEND c1 display) (SEND c2 display)))) (define act-p (eval p (interaction-environment))) (act-p)) Evolution of Software Languages 18

19 The Actor Model2 (define p (act->scheme '((define counter (BEHAVIOR (value) (METHOD (up n) (BECOME counter (+ value n))) (METHOD (down n) (BECOME counter (- value n))) (METHOD (display) (display "value=") (display value) (list 'lambda empty (list '$new$ '$scheduler$ (list 'lambda (list 'ignore) (list 'define 'counter (list (list 'lambda empty (list 'define 'methods (list '$make-dictionary$)) (list '$put$ 'methods (list 'quote 'up) (list 'lambda (list 'self 'become! 'value 'n) (list 'become! 'counter (list '+ 'value 'n)))) (list '$put$ 'methods (list 'quote 'down) (list 'lambda (list 'self 'become! 'value 'n) (list 'become! 'counter (list '- 'value 'n)))) (list '$put$ 'methods (list 'quote 'display) (list 'lambda (list 'self 'become! 'value) (list 'display "value=") (list 'display 'value) (list 'newline))) (list 'lambda (list 'args) (list 'define 'tail (list 'last 'args)) (list 'define (list 'dispatcher 'msg 'arg-list) (list 'set-cdr! 'tail 'arg-list) (list 'apply (list '$get$ 'methods 'msg) 'args)) 'dispatcher)))) (list 'define 'c1 (list '$make-actor$ 'counter 0)) (list 'define 'c2 (list '$make-actor$ 'counter 5)) (list '$new$ '$scheduler$ (list 'lambda (list 'ignore) (list (newline)))) '$switch$ '$scheduler$) (list 'c2 (list 'quote 'down) 2) (list '$exit$ '$scheduler$))) (list '$new$ '$scheduler$ (list 'lambda (list 'ignore) (list '$switch$ '$scheduler$) (list 'c1 (list 'quote 'up) 1) (list '$exit$ '$scheduler$))) (list '$new$ '$scheduler$ (list 'lambda (list 'ignore) (list (define c1 (NEW counter 0)) (define c2 (NEW counter 5)) '$switch$ '$scheduler$) (list 'c2 (list 'quote 'up) 5) (list '$exit$ '$scheduler$))) (list '$new$ '$scheduler$ (list 'lambda (list 'ignore) (list '$switch$ '$scheduler$) (list 'c1 (list 'quote 'display)) (list '$exit$ '$scheduler$))) (list '$new$ '$scheduler$ (list 'lambda (list 'ignore) (list '$switch$ '$scheduler$) (list 'c2 (list 'quote 'display)) (list '$exit$ '$scheduler$))) (list '$exit$ '$scheduler$))) (list '$start$ '$scheduler$)) (SEND c2 down 2) (SEND c1 up 1) (SEND c2 up 5) (SEND c1 display) (SEND c2 display)))) (define act-p (eval p (interaction-environment))) (act-p)) Evolution of Software Languages 19

20 The Actor Model2 (define p (act->scheme '((define counter (BEHAVIOR (value) (METHOD (up n) (BECOME counter (+ value n))) (METHOD (down n) (BECOME counter (- value n))) (METHOD (display) (display "value=") (display value) (newline)))) (list 'lambda empty (list '$new$ '$scheduler$ (list 'lambda (list 'ignore) (list 'define 'counter (list (list 'lambda empty (list 'define 'methods (list '$make-dictionary$)) (list '$put$ 'methods (list 'quote 'up) (list 'lambda (list 'self 'become! 'value 'n) (list 'become! 'counter (list '+ 'value 'n)))) (list '$put$ 'methods (list 'quote 'down) (list 'lambda (list 'self 'become! 'value 'n) (list 'become! 'counter (list '- 'value 'n)))) (list '$put$ 'methods (list 'quote 'display) (list 'lambda (list 'self 'become! 'value) (list 'display "value=") (list 'display 'value) (list 'newline))) (list 'lambda (list 'args) (list 'define 'tail (list 'last 'args)) (list 'define (list 'dispatcher 'msg 'arg-list) (list 'set-cdr! 'tail 'arg-list) (list 'apply (list '$get$ 'methods 'msg) 'args)) 'dispatcher)))) (list 'define 'c1 (list '$make-actor$ 'counter 0)) (list 'define 'c2 (list '$make-actor$ 'counter 5)) (list '$new$ '$scheduler$ (list 'lambda (list 'ignore) (list '$switch$ '$scheduler$) (list 'c2 (list 'quote 'down) 2) (list '$exit$ '$scheduler$))) (list '$new$ '$scheduler$ (list 'lambda (list 'ignore) (list '$switch$ '$scheduler$) (list 'c1 (list 'quote 'up) 1) (list '$exit$ '$scheduler$))) (define Welcome (list c1 (NEW to '$new$ counter DrScheme, '$scheduler$ (list 0)) version 'lambda (list 372 'ignore) [3m]. (list '$switch$ '$scheduler$) (list 'c2 (list 'quote 'up) 5) (list '$exit$ '$scheduler$))) (list '$new$ '$scheduler$ (list (define Language: 'lambda c2 (list (NEW 'ignore) Standard counter (list '$switch$ 5)) (R5RS) '$scheduler$) custom. (list 'c1 (list 'quote 'display)) (list '$exit$ '$scheduler$))) (list '$new$ '$scheduler$ (list 'lambda (list 'ignore) (list '$switch$ '$scheduler$) started (list 'c2 (list 'quote 'display)) (list '$exit$ '$scheduler$))) (list '$exit$ '$scheduler$))) (list '$start$ '$scheduler$)) (SEND c2 down 2) (SEND value=1 c1 up 1) (SEND value=8 c2 up 5) (SEND no c1 more display) processes (SEND c2 display)))) (define act-p (eval p (interaction-environment))) (act-p)) Evolution of Software Languages 20

21 The Actor Model3 <program> ::= <expression>* <expression> ::= <scheme-expression> <behavior-expression> <become-expression> <new-expression> <send-expression> <self-expression> <behavior-expression> ::= (BEHAVIOR (<acquaintance>*) <method>*) <become-expression> ::= (BECOME <expression> <expression>*) <new-expression> ::= (NEW <expression> <expression>*) <send-expression> ::= (SEND <expression> <message> <expression>*) <self-expression> ::= SELF <scheme-expression> ::= scheme-expression <method> <acquaintance> <message> <argument> ::= (METHOD (<message> <argument>*) <expression>*) ::= identifier ::= identifier ::= identifier Evolution of Software Languages 21

22 The Actor Model4 (define Factorial (BEHAVIOR () (METHOD (doit customer number) (BECOME Factorial) (display number) (newline) (if (= number 0) (SEND customer result 1) (let ((x (NEW FactCust customer number))) (SEND SELF doit x (- number 1))))))) Evolution of Software Languages 22

23 The Actor Model4 (define FactCust (BEHAVIOR (customer number1) (METHOD (result number2) (SEND customer result (* number1 number2))))) (define Factorial (BEHAVIOR () (METHOD (doit customer number) (BECOME Factorial) (display number) (newline) (if (= number 0) (SEND customer result 1) (let ((x (NEW FactCust customer number))) (SEND SELF doit x (- number 1))))))) Evolution of Software Languages 23

24 The Actor Model4 (define FactCust (BEHAVIOR (customer number1) (METHOD (result number2) (SEND customer result (* number1 number2))))) (define Factorial (BEHAVIOR () (METHOD (doit customer number) (BECOME Factorial) (define User (display number) (newline) (BEHAVIOR (fact) (if (= number 0) (METHOD (doit number) (SEND customer result 1) (SEND fact doit SELF number)) (let ((x (NEW FactCust customer number))) (METHOD (result number) (SEND SELF doit x (- number 1))))))) (display (list "Value= " number)) (newline)))) Evolution of Software Languages 24

25 The Actor Model4 (define FactCust (BEHAVIOR (customer number1) (METHOD (result number2) (SEND customer result (* number1 number2))))) (define Factorial (BEHAVIOR () (METHOD (doit customer number) (BECOME Factorial) (define User (display number) (newline) (BEHAVIOR (fact) (if (= number 0) (METHOD (doit number) (SEND customer result 1) (SEND fact doit SELF number)) (let ((x (NEW FactCust customer number))) (METHOD (result number) (SEND SELF doit x (- number 1))))))) (display (list "Value= " number)) (newline)))) (define fact (NEW Factorial)) (SEND (NEW User fact) doit 10) (SEND (NEW User fact) doit 4) Evolution of Software Languages 25

26 The Actor Model5 (define Fibonacci (BEHAVIOR (first second) (METHOD (fib customer number) (BECOME Fibonacci first second) (cond ((= number 0) (SEND customer result first)) ((= number 1) (SEND customer result second)) (else (let ((x (NEW FibCust customer))) (SEND SELF fib x (- number 1)) (SEND SELF fib x (- number 2)))))))) (define FibCust (BEHAVIOR (customer) (METHOD (result number) (BECOME FibCust2 customer number)))) (define FibCust2 (BEHAVIOR (customer number1) (METHOD (result number2) (SEND customer result (+ number1 number2)) (BECOME FibCust2 customer number1)))) (define User (BEHAVIOR (fibonacci) (METHOD (doit number) (BECOME User fibonacci) (SEND fibonacci fib (NEW Print) number)))) Evolution of Software Languages 26 (define Print (BEHAVIOR () (METHOD (result number) (BECOME Print) (display "result=") (display number) (newline)))) (define fib (NEW Fibonacci 1 1)) (SEND (NEW User fib) doit 6) (SEND (NEW User fib) doit 4)

27 The Actor Model6 Very high-level view on concurrency Most famous offshoot: Erlang Basis for process calculi Imperative (see BECOME) Asynchronous No (evident) global state Inherently concurrent (Unbounded) non deterministic Evolution of Software Languages 27

28 Guy Steele - Gerald Sussman Researchers at MIT Built "Scheme" Common Lisp SICP PhD with Seymour Papert PhD with should-we-fear-intelligent-machines/ Evolution of Software Languages 28

29 The case of Scheme from AIM-848 Evolution of Software Languages 29

30 Scheme and Actors This work developed out of an initial attempt to understand the. actorness of actors. Steele thought he understood it, but couldn't explain it; Sussman suggested the experimental approach of actually building an "ACTORS interpreter". This interpreter attempted to intermix the use of actors and LISP lambda expressions in a clean manner. When it was completed, we discovered that the "actors" and the lambda expressions were identical in implementation. Once we had discovered this, all the rest fell into place, and it was only natural to begin thinking about actors in terms of lambda calculus. The original interpreter was call-by-name for various reasons from AIM-349 Evolution of Software Languages 30

31 A timeline for Scheme1 43pp 35pp 76pp Evolution of Software Languages 31

32 A timeline for Scheme2 43pp 50pp 88pp pp 90pp DRAFT Evolution of Software Languages 32 + IEEE Standard

33 Semantics for Scheme1 AIM-349 informal lambda-calculus substitution semantics AIM-452 informal AIM-848 (RRRS)... a formal definition of the semantics of Scheme will be included in a separate report... R3RS denotational semantics + rewrite rules R4RS denotational semantics + rewrite rules + macros (added support for immutables) R5RS denotational semantics + syntactic forms R6RS operational semantics R7RS Evolution of Software Languages 33 denotational semantics + syntactic forms (added support for dynamic-wind)

34 Semantics for Scheme2 Page 33 from R3RS Evolution of Software Languages 34

35 e.g. argument evaluation (4) The argument forms (and procedure f'orm) may in principle be evaluated i n any order. This is unlike the usual LISP left-to-right order. (All SCHEI'lE interpreters implemented so far have in fact performed left-to-right evaluation, but we do not wish programs to depend on this fact. Indeed, the~e are some reasons why a clever interpreter might want to evaluate them right-to-left, e.g. to get things on a stack in the correct order.} AIM-452 A list whose first element is not the keyword of a special form indicates a procedure eall. The operator and operand expressions arevaluated and the resulting procedure is passed the resulting arguments. In contrast to other dialects of Lisp the order of evaluation is not specified, and the operator expression and the operand expressions are always evaluated with the same evaluation rules. AIM-848 R3RS R7RS \ R6RS The order of evaluation within a call is unspecified. We mimic that here by applying arbitrary permutations permute and unpermute, which must be inverses, to the arguments in a call before and after they are evaluated. This {still requires is not quite right since it suggests, incorrectly, } that the order of evaluation is constant throughout a program (for any given number of arguments), but it is a closer approximation to the intended semantics than a left-to-right evaluation would be. ℇ (E 0 E*) = λρκ. ℇ*(permute ( E 0 E*)) ρ (λε*. ((λε*. applicate (ε* 1) (ε* 1) κ) (unpermute ε*))) Evolution of Software Languages 35

36 Glitches1 Welcome to DrScheme, version 372 [3m]. Language: Standard (R5RS) custom. > (define (f) '(1. 2)) > (define z (f)) > (set-car! z 3) > z (cons 3 2) > (f) (cons 3 2) > Evolution of Software Languages 36

37 Evolution of Software Languages Glitches2 Welcome to DrScheme, version 372 [3m]. Language: Standard (R5RS) custom. > (define (f) (define x 1) (define y x) y) > (f) 1

38 Evolution of Software Languages Glitches2 Welcome to DrScheme, version 372 [3m]. Language: Standard (R5RS) custom. > (define (f) (define x 1) (define y x) y) > (f) 1 Welcome to DrScheme, version 6.0 [3m]. Language: Standard (R5RS) custom. > (define (f) (define x 1) (define y x) y) > (f) #<undefined>

39 Evolution of Software Languages Glitches2 Welcome to DrScheme, version 372 [3m]. Language: Standard (R5RS) custom. > (define (f) (define x 1) (define y x) y) > (f) 1 Welcome to DrScheme, version 6.0 [3m]. Language: Standard (R5RS) custom. > (define (f) (define x 1) (define y x) y) > (f) #<undefined> Welcome to DrScheme, version 6.0 [3m]. Language: Standard (R5RS) custom. > (define (f) (define x 1) (define y x) y) > (f) 1

40 Showcase: metacircularity1 (define circularity-level 0) ; only 1st time (begin (define old-circularity-level circularity-level) (define circularity-level (+ old-circularity-level 1)) (define meta-level-eval eval) (define eval '()) (define environment '()) (define (loop output) (define rollback environment) (define (evaluate expression)... ) (display output) (newline) (display "level") (display circularity-level) (display ">") (set! eval evaluate) (loop (evaluate (read)))) Evolution of Software Languages (loop "Lisp in 100 lines"))

41 Showcase: metacircularity2 Welcome to DrScheme, version 372 [3m]. Language: Standard (R5RS) custom. Lisp in 100 lines level:1>(begin (define old-circularity-level circularity-level) (define circularity-level (+ old-circularity-level 1)) (define meta-level-eval eval) (define eval '()) (define environment '()) (define (loop output)... this is where I feed the interpreter 3x to itself Lisp in 100 lines level:4>(+ 1 2) 3 Evolution of Software Languages

42 Showcase: metacircularity3 (define (evaluate expression) (define (error message qualifier) (display message) (set! environment rollback) (loop qualifier)) ; functions (define (bind-variable variable value)... (define (bind-parameters parameters arguments)... (define (evaluate-sequence expressions)... (define (make-procedure parameters expressions)... ; evaluation functions... (if (symbol? expression) (evaluate-variable expression) (if (pair? expression)... Evolution of Software Languages expression)))

43 Showcase: metacircularity3 (define (evaluate expression) (define (error message qualifier) (display message) (set! environment rollback) (if (symbol? expression) (loop qualifier)) (evaluate-variable expression) (if (pair? ; expression) functions (apply (if (equal? (define (car (bind-variable expression) 'begin) variable evaluate-begin value)... (if (equal? (define (car (bind-parameters expression) 'define) parameters evaluate-define arguments)... (if (define (equal? (evaluate-sequence (car expression) 'if) expressions) evaluate-if... (if (define (equal? (make-procedure (car expression) parameters 'lambda) expressions) evaluate-lambda... (if (equal? (car expression) 'quote) evaluate-quote ; evaluation (if (equal? functions (car expression) 'set!) evaluate-set! (evaluate-application (car expression)))))))) (cdr expression))... expression))) (if (symbol? expression) (evaluate-variable expression) (if (pair? expression)... Evolution of Software Languages expression)))

44 Showcase: metacircularity3 (define (evaluate expression) (define (error message qualifier) (display message) (set! environment rollback) (loop qualifier)) (define (make-procedure parameters expressions) (define lexical-environment environment) ; functions (define procedure '()) (lambda arguments (define (bind-variable variable value)... (define dynamic-environment environment) (define (bind-parameters parameters arguments)... (set! environment lexical-environment) (define (evaluate-sequence expressions)... (bind-parameters parameters arguments) (define (make-procedure parameters expressions)... (begin (set! procedure (evaluate-sequence expressions)) ; evaluation functions (set! environment dynamic-environment) procedure)))... (if (symbol? expression) (evaluate-variable expression) (if (pair? expression)... Evolution of Software Languages expression)))

45 Conclusion Arguably the most expressive programming language Also the first grounded programming language Source of inspiration for many other languages The start of functional programming The start of language semantics The start of metaprogramming and reflection The starting platform for AI Continues with Common Lisp as a commercially viable platform And also so many things more... Evolution of Software Languages 45

46 Assignment 1. Construct an unbounded queue in the actor model 2. Make Lisp-in-100-lines run in Racket 3. Translate it into (a) Lisp Evolution of Software Languages 46

Functional Programming. Pure Functional Languages

Functional Programming. Pure Functional Languages Functional Programming Pure functional PLs S-expressions cons, car, cdr Defining functions read-eval-print loop of Lisp interpreter Examples of recursive functions Shallow, deep Equality testing 1 Pure

More information

Organization of Programming Languages CS3200/5200N. Lecture 11

Organization of Programming Languages CS3200/5200N. Lecture 11 Organization of Programming Languages CS3200/5200N Razvan C. Bunescu School of Electrical Engineering and Computer Science bunescu@ohio.edu Functional vs. Imperative The design of the imperative languages

More information

COMMOM OBJECT ORIENTED LISP SYSTEMS

COMMOM OBJECT ORIENTED LISP SYSTEMS COMMOM OBJECT ORIENTED LISP SYSTEMS HISTORY: The following information is derived from the history section of dpans Common Lisp. Lisp is a family of languages with a long history. Early key ideas in Lisp

More information

Scheme. Functional Programming. Lambda Calculus. CSC 4101: Programming Languages 1. Textbook, Sections , 13.7

Scheme. Functional Programming. Lambda Calculus. CSC 4101: Programming Languages 1. Textbook, Sections , 13.7 Scheme Textbook, Sections 13.1 13.3, 13.7 1 Functional Programming Based on mathematical functions Take argument, return value Only function call, no assignment Functions are first-class values E.g., functions

More information

Common LISP-Introduction

Common LISP-Introduction Common LISP-Introduction 1. The primary data structure in LISP is called the s-expression (symbolic expression). There are two basic types of s-expressions: atoms and lists. 2. The LISP language is normally

More information

Allegro CL Certification Program

Allegro CL Certification Program Allegro CL Certification Program Lisp Programming Series Level I Presented by 1 About David Margolies Manager, Documentation, Franz Inc Been working with Lisp since 1984 dm@franz.com 2 About Franz Inc.

More information

Common Lisp. Blake McBride

Common Lisp. Blake McBride Contents Common Lisp Blake McBride (blake@mcbride.name) 1 Data Types 2 2 Numeric Hierarchy 3 3 Comments 3 4 List Operations 4 5 Evaluation and Quotes 5 6 String Operations 5 7 Predicates 6 8 Math Predicates

More information

Racket. CSE341: Programming Languages Lecture 14 Introduction to Racket. Getting started. Racket vs. Scheme. Example.

Racket. CSE341: Programming Languages Lecture 14 Introduction to Racket. Getting started. Racket vs. Scheme. Example. Racket Next 2+ weeks will use the Racket language (not ML) and the DrRacket programming environment (not emacs) Installation / basic usage instructions on course website CSE34: Programming Languages Lecture

More information

Lecture #2 Kenneth W. Flynn RPI CS

Lecture #2 Kenneth W. Flynn RPI CS Outline Programming in Lisp Lecture #2 Kenneth W. Flynn RPI CS Items from last time Recursion, briefly How to run Lisp I/O, Variables and other miscellany Lists Arrays Other data structures Jin Li lij3@rpi.edu

More information

Project 2: Scheme Interpreter

Project 2: Scheme Interpreter Project 2: Scheme Interpreter CSC 4101, Fall 2017 Due: 12 November 2017 For this project, you will implement a simple Scheme interpreter in C++ or Java. Your interpreter should be able to handle the same

More information

CS61A Discussion Notes: Week 11: The Metacircular Evaluator By Greg Krimer, with slight modifications by Phoebus Chen (using notes from Todd Segal)

CS61A Discussion Notes: Week 11: The Metacircular Evaluator By Greg Krimer, with slight modifications by Phoebus Chen (using notes from Todd Segal) CS61A Discussion Notes: Week 11: The Metacircular Evaluator By Greg Krimer, with slight modifications by Phoebus Chen (using notes from Todd Segal) What is the Metacircular Evaluator? It is the best part

More information

A Genetic Algorithm Implementation

A Genetic Algorithm Implementation A Genetic Algorithm Implementation Roy M. Turner (rturner@maine.edu) Spring 2017 Contents 1 Introduction 3 2 Header information 3 3 Class definitions 3 3.1 Individual..........................................

More information

Announcement. Overview. LISP: A Quick Overview. Outline of Writing and Running Lisp.

Announcement. Overview. LISP: A Quick Overview. Outline of Writing and Running Lisp. Overview Announcement Announcement Lisp Basics CMUCL to be available on sun.cs. You may use GNU Common List (GCL http://www.gnu.org/software/gcl/ which is available on most Linux platforms. There is also

More information

Introduction to Lisp

Introduction to Lisp Last update: February 16, 2010 Introduction to Lisp Dana Nau Dana Nau 1 Outline I assume you know enough about computer languages that you can learn new ones quickly, so I ll go pretty fast If I go too

More information

Symbolic Programming. Dr. Zoran Duric () Symbolic Programming 1/ 89 August 28, / 89

Symbolic Programming. Dr. Zoran Duric () Symbolic Programming 1/ 89 August 28, / 89 Symbolic Programming Symbols: +, -, 1, 2 etc. Symbolic expressions: (+ 1 2), (+ (* 3 4) 2) Symbolic programs are programs that manipulate symbolic expressions. Symbolic manipulation: you do it all the

More information

Recursive Functions of Symbolic Expressions and Their Application, Part I

Recursive Functions of Symbolic Expressions and Their Application, Part I Recursive Functions of Symbolic Expressions and Their Application, Part I JOHN MCCARTHY Review: Amit Kirschenbaum Seminar in Programming Languages Recursive Functions of Symbolic Expressions and Their

More information

Functional programming techniques

Functional programming techniques Functional programming techniques o Currying o Continuations o Streams. Lazy evaluation Currying o Haskell B. Curry. o Second-order programming: o Functions that return other functions. o Example: A two-arguments

More information

An Introduction to Scheme

An Introduction to Scheme An Introduction to Scheme Stéphane Ducasse stephane.ducasse@inria.fr http://stephane.ducasse.free.fr/ Stéphane Ducasse 1 Scheme Minimal Statically scoped Functional Imperative Stack manipulation Specification

More information

CS 480. Lisp J. Kosecka George Mason University. Lisp Slides

CS 480. Lisp J. Kosecka George Mason University. Lisp Slides CS 480 Lisp J. Kosecka George Mason University Lisp Slides Symbolic Programming Symbols: +, -, 1, 2 etc. Symbolic expressions: (+ 1 2), (+ (* 3 4) 2) Symbolic programs are programs that manipulate symbolic

More information

Project 5 - The Meta-Circular Evaluator

Project 5 - The Meta-Circular Evaluator MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science 6.001 Structure and Interpretation of Computer Programs Fall Semester, 2005 Project 5 - The Meta-Circular

More information

The Design and Implementation of a Modern Lisp. Dialect

The Design and Implementation of a Modern Lisp. Dialect The Design and Implementation of a Modern Lisp Dialect Sam Davis Nicholas Alexander January 26, 2006 Abstract Lisp, invented in 1958 by John McCarthy, revolutionized how programs could be written and expressed.

More information

(defvar *state* nil "The current state: a list of conditions.")

(defvar *state* nil The current state: a list of conditions.) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; GPS engine for blocks world ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defvar *dbg-ids* nil "Identifiers used by dbg") (defvar *state* nil "The current state: a list of conditions.")

More information

(Func&onal (Programming (in (Scheme)))) Jianguo Lu

(Func&onal (Programming (in (Scheme)))) Jianguo Lu (Func&onal (Programming (in (Scheme)))) Jianguo Lu 1 Programming paradigms Func&onal No assignment statement No side effect Use recursion Logic OOP AOP 2 What is func&onal programming It is NOT what you

More information

Allegro CL Certification Program

Allegro CL Certification Program Allegro CL Certification Program Lisp Programming Series Level I Review David Margolies 1 Summary 1 A lisp session contains a large number of objects which is typically increased by user-created lisp objects

More information

Fall 2017 Discussion 7: October 25, 2017 Solutions. 1 Introduction. 2 Primitives

Fall 2017 Discussion 7: October 25, 2017 Solutions. 1 Introduction. 2 Primitives CS 6A Scheme Fall 207 Discussion 7: October 25, 207 Solutions Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write

More information

Lecture Notes on Lisp A Brief Introduction

Lecture Notes on Lisp A Brief Introduction Why Lisp? Lecture Notes on Lisp A Brief Introduction Because it s the most widely used AI programming language Because Prof Peng likes using it Because it s good for writing production software (Graham

More information

CIS4/681 { Articial Intelligence 2 > (insert-sort '( )) ( ) 2 More Complicated Recursion So far everything we have dened requires

CIS4/681 { Articial Intelligence 2 > (insert-sort '( )) ( ) 2 More Complicated Recursion So far everything we have dened requires 1 A couple of Functions 1 Let's take another example of a simple lisp function { one that does insertion sort. Let us assume that this sort function takes as input a list of numbers and sorts them in ascending

More information

CS 842 Ben Cassell University of Waterloo

CS 842 Ben Cassell University of Waterloo CS 842 Ben Cassell University of Waterloo Recursive Descent Re-Cap Top-down parser. Works down parse tree using the formal grammar. Built from mutually recursive procedures. Typically these procedures

More information

Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003

Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003 Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003 CS 314, LS, LTM: Functional Programming 1 Scheme A program is an expression to be evaluated (in

More information

ALISP interpreter in Awk

ALISP interpreter in Awk ALISP interpreter in Awk Roger Rohrbach 1592 Union St., #94 San Francisco, CA 94123 January 3, 1989 ABSTRACT This note describes a simple interpreter for the LISP programming language, written in awk.

More information

regsim.scm ~/umb/cs450/ch5.base/ 1 11/11/13

regsim.scm ~/umb/cs450/ch5.base/ 1 11/11/13 1 File: regsim.scm Register machine simulator from section 5.2 of STRUCTURE AND INTERPRETATION OF COMPUTER PROGRAMS This file can be loaded into Scheme as a whole. Then you can define and simulate machines

More information

Languages as Libraries

Languages as Libraries Languages as Libraries or, implementing the next 700 programming languages Sam Tobin-Hochstadt PLT @ Northeastern University May 11, 2011 MIT 1 A domain specific language is the ultimate abstraction. Paul

More information

Architecture of LISP Machines. Kshitij Sudan March 6, 2008

Architecture of LISP Machines. Kshitij Sudan March 6, 2008 Architecture of LISP Machines Kshitij Sudan March 6, 2008 A Short History Lesson Alonzo Church and Stephen Kleene (1930) λ Calculus ( to cleanly define "computable functions" ) John McCarthy (late 60 s)

More information

Robot Programming with Lisp

Robot Programming with Lisp 4. Functional Programming: Higher-order Functions, Map/Reduce, Lexical Scope Institute for Artificial University of Bremen 9 of November, 2017 Functional Programming Pure functional programming concepts

More information

19 Machine Learning in Lisp

19 Machine Learning in Lisp 19 Machine Learning in Lisp Chapter Objectives Chapter Contents ID3 algorithm and inducing decision trees from lists of examples. A basic Lisp implementation of ID3 Demonstration on a simple credit assessment

More information

Racket: Macros. Advanced Functional Programming. Jean-Noël Monette. November 2013

Racket: Macros. Advanced Functional Programming. Jean-Noël Monette. November 2013 Racket: Macros Advanced Functional Programming Jean-Noël Monette November 2013 1 Today Macros pattern-based macros Hygiene Syntax objects and general macros Examples 2 Macros (According to the Racket Guide...)

More information

Interpreters and Tail Calls Fall 2017 Discussion 8: November 1, 2017 Solutions. 1 Calculator. calc> (+ 2 2) 4

Interpreters and Tail Calls Fall 2017 Discussion 8: November 1, 2017 Solutions. 1 Calculator. calc> (+ 2 2) 4 CS 61A Interpreters and Tail Calls Fall 2017 Discussion 8: November 1, 2017 Solutions 1 Calculator We are beginning to dive into the realm of interpreting computer programs that is, writing programs that

More information

CSCI 3155: Principles of Programming Languages Exam preparation #1 2007

CSCI 3155: Principles of Programming Languages Exam preparation #1 2007 CSCI 3155: Principles of Programming Languages Exam preparation #1 2007 Exercise 1. Consider the if-then-else construct of Pascal, as in the following example: IF 1 = 2 THEN PRINT X ELSE PRINT Y (a) Assume

More information

Emacs Lisp Introduction

Emacs Lisp Introduction Emacs Lisp Introduction GNU Emacs is a full-featured text editor that contains a complete Lisp system that allows the user to write programs that control the editor. Dozens of applications have been written

More information

Programming Languages. Function-Closure Idioms. Adapted from Dan Grossman's PL class, U. of Washington

Programming Languages. Function-Closure Idioms. Adapted from Dan Grossman's PL class, U. of Washington Programming Languages Function-Closure Idioms Adapted from Dan Grossman's PL class, U. of Washington More idioms We know the rule for lexical scope and function closures Now what is it good for A partial

More information

Department of Computer and information Science Norwegian University of Science and Technology

Department of Computer and information Science Norwegian University of Science and Technology Department of Computer and information Science Norwegian University of Science and Technology http://www.idi.ntnu.no/ A Crash Course in LISP MNFIT272 2002 Anders Kofod-Petersen anderpe@idi.ntnu.no Introduction

More information

A Brief Introduction to Scheme (I)

A Brief Introduction to Scheme (I) A Brief Introduction to Scheme (I) Philip W. L. Fong pwlfong@cs.uregina.ca Department of Computer Science University of Regina Regina, Saskatchewan, Canada Scheme Scheme I p.1/44 Scheme: Feature Set A

More information

A LISP Interpreter in ML

A LISP Interpreter in ML UNIVERSITY OF OSLO Department of Informatics A LISP Interpreter in ML Mandatory Assignment 1 INF3110 September 21, 2009 Contents 1 1 Introduction The purpose of this assignment is to write an interpreter,

More information

A Quick Introduction to Common Lisp

A Quick Introduction to Common Lisp CSC 244/444 Notes last updated ug. 30, 2016 Quick Introduction to Common Lisp Lisp is a functional language well-suited to symbolic I, based on the λ-calculus and with list structures as a very flexible

More information

SCHEME 7. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. October 29, 2015

SCHEME 7. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. October 29, 2015 SCHEME 7 COMPUTER SCIENCE 61A October 29, 2015 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

More information

Fifth Generation CS 4100 LISP. What do we need? Example LISP Program 11/13/13. Chapter 9: List Processing: LISP. Central Idea: Function Application

Fifth Generation CS 4100 LISP. What do we need? Example LISP Program 11/13/13. Chapter 9: List Processing: LISP. Central Idea: Function Application Fifth Generation CS 4100 LISP From Principles of Programming Languages: Design, Evaluation, and Implementation (Third Edition, by Bruce J. MacLennan, Chapters 9, 10, 11, and based on slides by Istvan Jonyer

More information

RbCl: A Reective Object-Oriented Concurrent Language. without a Run-time Kernel. Yuuji Ichisugi, Satoshi Matsuoka, Akinori Yonezawa

RbCl: A Reective Object-Oriented Concurrent Language. without a Run-time Kernel. Yuuji Ichisugi, Satoshi Matsuoka, Akinori Yonezawa RbCl: A Reective Object-Oriented Concurrent Language without a Run-time Kernel Yuuji Ichisugi, Satoshi Matsuoka, Akinori Yonezawa Department of Information Science, The University of Tokyo 3 Abstract We

More information

MORE SCHEME. 1 What Would Scheme Print? COMPUTER SCIENCE MENTORS 61A. October 30 to November 3, Solution: Solutions begin on the following page.

MORE SCHEME. 1 What Would Scheme Print? COMPUTER SCIENCE MENTORS 61A. October 30 to November 3, Solution: Solutions begin on the following page. MORE SCHEME COMPUTER SCIENCE MENTORS 61A October 30 to November 3, 2017 1 What Would Scheme Print? Solutions begin on the following page. 1. What will Scheme output? Draw box-and-pointer diagrams to help

More information

Debugging in LISP. trace causes a trace to be printed for a function when it is called

Debugging in LISP. trace causes a trace to be printed for a function when it is called trace causes a trace to be printed for a function when it is called ;;; a function that works like reverse (defun rev (list) (cons (first (last list)) (rev (butlast list)))) USER: (trace rev) ; note trace

More information

Object Oriented Programming (OOP)

Object Oriented Programming (OOP) Object Oriented Programming (OOP) o New programming paradigm o Actions Objects o Objects Actions o Object-oriented = Objects + Classes + Inheritance Imperative programming o OOP (Object-Oriented Programming)

More information

Fundamentals of Artificial Intelligence COMP221: Functional Programming in Scheme (and LISP)

Fundamentals of Artificial Intelligence COMP221: Functional Programming in Scheme (and LISP) Fundamentals of Artificial Intelligence COMP221: Functional Programming in Scheme (and LISP) Prof. Dekai Wu Department of Computer Science and Engineering The Hong Kong University of Science and Technology

More information

Scheme: Data. CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Monday, April 3, Glenn G.

Scheme: Data. CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Monday, April 3, Glenn G. Scheme: Data CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Monday, April 3, 2017 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks ggchappell@alaska.edu

More information

Project 5 - The Meta-Circular Evaluator

Project 5 - The Meta-Circular Evaluator MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science 6.001 Structure and Interpretation of Computer Programs Spring Semester, 2005 Project 5 - The Meta-Circular

More information

Custom Specializers in Object-Oriented Lisp

Custom Specializers in Object-Oriented Lisp Custom Cadence Design Systems Goldsmiths, University of London 23rd May 2008 Common : Skill: Unification of various dialects; Not dead yet. Common Skill Internal dialect from Cadence Design Systems; Extension

More information

Scheme as implemented by Racket

Scheme as implemented by Racket Scheme as implemented by Racket (Simple view:) Racket is a version of Scheme. (Full view:) Racket is a platform for implementing and using many languages, and Scheme is one of those that come out of the

More information

SOFTWARE ARCHITECTURE 6. LISP

SOFTWARE ARCHITECTURE 6. LISP 1 SOFTWARE ARCHITECTURE 6. LISP Tatsuya Hagino hagino@sfc.keio.ac.jp slides URL https://vu5.sfc.keio.ac.jp/sa/ 2 Compiler vs Interpreter Compiler Translate programs into machine languages Compilers are

More information

Every language has its own scoping rules. For example, what is the scope of variable j in this Java program?

Every language has its own scoping rules. For example, what is the scope of variable j in this Java program? Lexical Binding There are two ways a variable can be used in a program: As a declaration As a "reference" or use of the variable Scheme has two kinds of variable "declarations" -- the bindings of a let-expression

More information

Essentials of Programming Languages Language

Essentials of Programming Languages Language Essentials of Programming Languages Language Version 6.90.0.26 April 20, 2018 The Essentials of Programming Languages language in DrRacket provides a subset of functions and syntactic forms of racket mostly

More information

(defmacro while (condition &body body) `(iterate loop () (if,condition (loop)))))

(defmacro while (condition &body body) `(iterate loop () (if,condition (loop))))) ; PARCIL - A Parser for C syntax In Lisp version 0.1a copyright (c) 1992 by Erann Gat, all rights reserved This program is free software; you can redistribute it and/or modify it under the terms of the

More information

1 CLWEB INTRODUCTION 1

1 CLWEB INTRODUCTION 1 1 CLWEB INTRODUCTION 1 1. Introduction. This is CLWEB, a literate programming system for Common Lisp by Alex Plotnick plotnick@cs.brandeis.edu. It is modeled after the CWEB system by Silvio Levy and Donald

More information

Problem Set 4: Streams and Lazy Evaluation

Problem Set 4: Streams and Lazy Evaluation Due Friday, March 24 Computer Science (1)21b (Spring Term, 2017) Structure and Interpretation of Computer Programs Problem Set 4: Streams and Lazy Evaluation Reading Assignment: Chapter 3, Section 3.5.

More information

Scheme Quick Reference

Scheme Quick Reference Scheme Quick Reference COSC 18 Fall 2003 This document is a quick reference guide to common features of the Scheme language. It is not intended to be a complete language reference, but it gives terse summaries

More information

UMBC CMSC 331 Final Exam Section 0101 December 17, 2002

UMBC CMSC 331 Final Exam Section 0101 December 17, 2002 0 / 0 1 / 20 UMBC CMSC 331 Final Exam Section 0101 December 17, 2002 Name: Student ID#: 2 / 25 3 / 20 4 / 25 5 / 20 6 /40 7 /40 You will have two hours to complete this closed book exam. We reserve the

More information

2. Reasons for implementing clos-unit

2. Reasons for implementing clos-unit A CLOS Implementation of the JUnit Testing Framework Architecture: A Case Study Sandro Pedrazzini Canoo Engineering AG sandro.pedrazzini@canoo.com Abstract There are different reasons why you would like

More information

Intro. Scheme Basics. scm> 5 5. scm>

Intro. Scheme Basics. scm> 5 5. scm> Intro Let s take some time to talk about LISP. It stands for LISt Processing a way of coding using only lists! It sounds pretty radical, and it is. There are lots of cool things to know about LISP; if

More information

A Brief Introduction to Scheme (II)

A Brief Introduction to Scheme (II) A Brief Introduction to Scheme (II) Philip W. L. Fong pwlfong@cs.uregina.ca Department of Computer Science University of Regina Regina, Saskatchewan, Canada Lists Scheme II p.1/29 Lists Aggregate data

More information

Vectors in Scheme. Data Structures in Scheme

Vectors in Scheme. Data Structures in Scheme Data Structures in Scheme Vectors in Scheme In Scheme, lists and S-expressions are basic. Arrays can be simulated using lists, but access to elements deep in the list can be slow (since a list is a linked

More information

;;; Determines if e is a primitive by looking it up in the primitive environment. ;;; Define indentation and output routines for the output for

;;; Determines if e is a primitive by looking it up in the primitive environment. ;;; Define indentation and output routines for the output for Page 1/11 (require (lib "trace")) Allow tracing to be turned on and off (define tracing #f) Define a string to hold the error messages created during syntax checking (define error msg ""); Used for fancy

More information

Building a system for symbolic differentiation

Building a system for symbolic differentiation Computer Science 21b Structure and Interpretation of Computer Programs Building a system for symbolic differentiation Selectors, constructors and predicates: (constant? e) Is e a constant? (variable? e)

More information

Object oriented programming

Object oriented programming Object oriented programming The main ideas behind object-oriented programming: the same type of action may be carried out differently on different types of objects cutting a cake is different from cutting

More information

Normal Order (Lazy) Evaluation SICP. Applicative Order vs. Normal (Lazy) Order. Applicative vs. Normal? How can we implement lazy evaluation?

Normal Order (Lazy) Evaluation SICP. Applicative Order vs. Normal (Lazy) Order. Applicative vs. Normal? How can we implement lazy evaluation? Normal Order (Lazy) Evaluation Alternative models for computation: Normal (Lazy) Order Evaluation Memoization Streams Applicative Order: evaluate all arguments, then apply operator Normal Order: pass unevaluated

More information

MIDTERM EXAMINATION - CS130 - Spring 2005

MIDTERM EXAMINATION - CS130 - Spring 2005 MIDTERM EAMINATION - CS130 - Spring 2005 Your full name: Your UCSD ID number: This exam is closed book and closed notes Total number of points in this exam: 231 + 25 extra credit This exam counts for 25%

More information

Homework. Reading: Chapter 17 Homework: All exercises from Chapter 17 Due: 10/27 Correction: Chapter 16 homework is due 10/25

Homework. Reading: Chapter 17 Homework: All exercises from Chapter 17 Due: 10/27 Correction: Chapter 16 homework is due 10/25 Homework Reading: Chapter 17 Homework: All exercises from Chapter 17 Due: 10/27 Correction: Chapter 16 homework is due 10/25 Copyright c 2002 2017 UMaine Computer Science Department 1 / 33 1 COS 140: Foundations

More information

This exam is worth 30 points, or 18.75% of your total course grade. The exam contains

This exam is worth 30 points, or 18.75% of your total course grade. The exam contains CS 60A Final May 16, 1992 Your name Discussion section number TA's name This exam is worth 30 points, or 18.75% of your total course grade. The exam contains six questions. This booklet contains eleven

More information

Functional abstraction. What is abstraction? Eating apples. Readings: HtDP, sections Language level: Intermediate Student With Lambda

Functional abstraction. What is abstraction? Eating apples. Readings: HtDP, sections Language level: Intermediate Student With Lambda Functional abstraction Readings: HtDP, sections 19-24. Language level: Intermediate Student With Lambda different order used in lecture section 24 material introduced much earlier sections 22, 23 not covered

More information

CMSC 331 Final Exam Section 0201 December 18, 2000

CMSC 331 Final Exam Section 0201 December 18, 2000 CMSC 331 Final Exam Section 0201 December 18, 2000 Name: nswers Student ID#: You will have two hours to complete this closed book exam. We reserve the right to assign partial credit, and to deduct points

More information

Name EID. (calc (parse '{+ {with {x {+ 5 5}} {with {y {- x 3}} {+ y y} } } z } ) )

Name EID. (calc (parse '{+ {with {x {+ 5 5}} {with {y {- x 3}} {+ y y} } } z } ) ) CS 345 Spring 2010 Midterm Exam Name EID 1. [4 Points] Circle the binding instances in the following expression: (calc (parse '+ with x + 5 5 with y - x 3 + y y z ) ) 2. [7 Points] Using the following

More information

Racket: Modules, Contracts, Languages

Racket: Modules, Contracts, Languages Racket: Modules, Contracts, Languages Advanced Functional Programming Jean-Noël Monette November 2013 1 Today Modules are the way to structure larger programs in smaller pieces. Modules can import and

More information

Queue-based Multi-processing Lisp

Queue-based Multi-processing Lisp Queue-based Multi-processing Lisp Richard P. Gabriel John McCarthy Stanford University 1. Introduction As the need for high-speed computers increases, the need for multi-processors will be become more

More information

It s Turtles All the Way Up: Self-Extensible Programming Languages in PLT Scheme

It s Turtles All the Way Up: Self-Extensible Programming Languages in PLT Scheme It s Turtles All the Way Up: Self-Extensible Programming Languages in PLT Scheme Matthew Flatt University of Utah 1 Different levels of extension... Syntactic abstraction (define-syntax-rule (define-thing

More information

Functions and Recursion. Dr. Philip Cannata 1

Functions and Recursion. Dr. Philip Cannata 1 Functions and Recursion Dr. Philip Cannata 1 10 High Level Languages This Course Java (Object Oriented) Jython in Java Relation ASP RDF (Horn Clause Deduction, Semantic Web) Dr. Philip Cannata 2 let transformation,

More information

low and not larger than high. 18 points

low and not larger than high. 18 points CSE 330 Test 1 (1 point) Spring 015 Multiple Choice. Write your answer to the LEFT of each problem. 3 points each 1. Lisp was invented at: A. IBM B. MIT C. Netscape D. Stanford. In C++, what operator is

More information

Lisp: Lab Information. Donald F. Ross

Lisp: Lab Information. Donald F. Ross Lisp: Lab Information Donald F. Ross General Model program source text stream What you need to write lexical analysis lexemes tokens syntax analysis is_id, is_number etc. + grammar rules + symbol table

More information

Quote of the Day. CS Functional Programming. Introductory Notes on Lisp/Clojure. Another Quote. What is Clojure? 1-4

Quote of the Day. CS Functional Programming. Introductory Notes on Lisp/Clojure. Another Quote. What is Clojure? 1-4 Quote of the Day CS 326 - Functional Programming Introductory Notes on Lisp/Clojure Dr. Stephen P. Carl By relieving the brain of all unnecessary work, a good notation sets it free to concentrate on more

More information

The Art of Lisp Programming

The Art of Lisp Programming The Art of Lisp Programming Robin Jones Clive Maynard Ian Stewart The Art of Lisp Programming With 12 Illustrations Springer-Verlag London Berlin Heidelberg N ew York Paris Tokyo Hong Kong Robin Jones

More information

Context-oriented Software Transactional Memory in Common Lisp

Context-oriented Software Transactional Memory in Common Lisp Context-oriented Software Transactional Memory in Common Lisp Pascal Costanza Charlotte Herzeel Theo D Hondt Software Languages Lab Vrije Universiteit Brussel B-1050 Brussels, Belgium pascal.costanza -

More information

Meet the Macro. a quick introduction to Lisp macros. Patrick Stein / TC Lisp Users Group /

Meet the Macro. a quick introduction to Lisp macros. Patrick Stein / TC Lisp Users Group / Meet the Macro a quick introduction to Lisp macros Patrick Stein / TC Lisp Users Group / 2009-07-14 Attack Plan Some other things called macros First look at Lisp macros More advanced macros Uh-oh, my

More information

Class 6: Efficiency in Scheme

Class 6: Efficiency in Scheme Class 6: Efficiency in Scheme SI 413 - Programming Languages and Implementation Dr. Daniel S. Roche United States Naval Academy Fall 2011 Roche (USNA) SI413 - Class 6 Fall 2011 1 / 10 Objects in Scheme

More information

NST: A Unit Test Framework for Common Lisp

NST: A Unit Test Framework for Common Lisp Smart Information Flow Technologies (SIFT, LLC) TC-lispers, June 9, 2009 Outline 1 Unit testing 2 3 The basic idea Early implementations, and other lessons How it maybe should work 4 What is unit testing?

More information

Reading: Chapter 17 Homework: All exercises from Chapter 17 Due: 10/27 Correction: Chapter 16 homework is due 10/25

Reading: Chapter 17 Homework: All exercises from Chapter 17 Due: 10/27 Correction: Chapter 16 homework is due 10/25 Homework Reading: Chapter 17 Homework: All exercises from Chapter 17 Due: 10/27 Correction: Chapter 16 homework is due 10/25 Copyright c 2002 2017 UMaine School of Computing and Information S 1 / 33 COS

More information

CSCI 2210: Programming in Lisp. Progn. Block. CSCI Programming in Lisp; Instructor: Alok Mehta 1. ANSI Common Lisp, Chapters 5-10

CSCI 2210: Programming in Lisp. Progn. Block. CSCI Programming in Lisp; Instructor: Alok Mehta 1. ANSI Common Lisp, Chapters 5-10 CSCI 2210: Programming in Lisp ANSI Common Lisp, Chapters 5-10 CSCI 2210 - Programming in Lisp; Instructor: Alok Mehta; 4.ppt 1 Progn Progn Creates a block of code Expressions in body are evaluated Value

More information

Scheme Basics > (butfirst '(help!)) ()

Scheme Basics > (butfirst '(help!)) () Scheme Basics > (butfirst '(help!)) () [The butfirst of a *sentence* containing one word is all but that word, i.e., the empty sentence. (BUTFIRST 'HELP!) without the inner parentheses would be butfirst

More information

Programming Languages Third Edition. Chapter 7 Basic Semantics

Programming Languages Third Edition. Chapter 7 Basic Semantics Programming Languages Third Edition Chapter 7 Basic Semantics Objectives Understand attributes, binding, and semantic functions Understand declarations, blocks, and scope Learn how to construct a symbol

More information

Sprite an animation manipulation language Language Reference Manual

Sprite an animation manipulation language Language Reference Manual Sprite an animation manipulation language Language Reference Manual Team Leader Dave Smith Team Members Dan Benamy John Morales Monica Ranadive Table of Contents A. Introduction...3 B. Lexical Conventions...3

More information

Why Macros? Scheme-Style Macros: Patterns and Lexical Scope. Macros versus Arbitrary Program Generators. Macros versus Arbitrary Program Generators

Why Macros? Scheme-Style Macros: Patterns and Lexical Scope. Macros versus Arbitrary Program Generators. Macros versus Arbitrary Program Generators Why Macros? Scheme-Style Macros: Patterns and Lexical Scope Language designers have to stop somewhere Matthew Flatt University of Utah (544 pages) No language can provide every possible useful construct

More information

Week 2: The Clojure Language. Background Basic structure A few of the most useful facilities. A modernized Lisp. An insider's opinion

Week 2: The Clojure Language. Background Basic structure A few of the most useful facilities. A modernized Lisp. An insider's opinion Week 2: The Clojure Language Background Basic structure A few of the most useful facilities A modernized Lisp Review of Lisp's origins and development Why did Lisp need to be modernized? Relationship to

More information

6.001, Spring Semester, 1998, Final Exam Your Name: 2 Question 1 (12 points): Each of the parts below should be treated as independent. For each part,

6.001, Spring Semester, 1998, Final Exam Your Name: 2 Question 1 (12 points): Each of the parts below should be treated as independent. For each part, 1 MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science 6.001 Structure and Interpretation of Computer Programs Spring Semester, 1998, Final Exam Your Name: Open

More information

STREAMS 10. Basics of Streams. Practice with Streams COMPUTER SCIENCE 61AS. 1. What is a stream?

STREAMS 10. Basics of Streams. Practice with Streams COMPUTER SCIENCE 61AS. 1. What is a stream? STREAMS 10 COMPUTER SCIENCE 61AS Basics of Streams 1. What is a stream? A stream is an element and a promise to evaluate the rest of the stream. Streams are a clever idea that allows one to use sequence

More information

What s different about Factor?

What s different about Factor? Harshal Lehri What s different about Factor? Factor is a concatenative programming language - A program can be viewed as a series of functions applied on data Factor is a stack oriented program - Data

More information

The Users Guide. and. API Reference

The Users Guide. and. API Reference McCLIM User s Manual The Users Guide and API Reference Copyright c 2004,2005,2006,2007,2008,2017 the McCLIM hackers. i Table of Contents Introduction......................................... 1 Standards...........................................................

More information