Upload
others
View
1
Download
0
Embed Size (px)
Citation preview
CS345H: Programming Languages
Lecture: LISP
Thomas Dillig
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 1/30
Historical Perspective
I Second oldest programming language after Fortran
I Developed in late 1950’s at MIT by John McCarthy
I Original purpose: to facilitate research in artificial intelligence
I In research, one may not initially know solution to problem;thus, development of program and research hand-in-hand
I Thus, program may need to be changed radically as a result ofexperimental evaluation: exploratory programming
I LISP is popular for exploratory programming
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 2/30
Historical Perspective
I Second oldest programming language after Fortran
I Developed in late 1950’s at MIT by John McCarthy
I Original purpose: to facilitate research in artificial intelligence
I In research, one may not initially know solution to problem;thus, development of program and research hand-in-hand
I Thus, program may need to be changed radically as a result ofexperimental evaluation: exploratory programming
I LISP is popular for exploratory programming
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 2/30
Historical Perspective
I Second oldest programming language after Fortran
I Developed in late 1950’s at MIT by John McCarthy
I Original purpose: to facilitate research in artificial intelligence
I In research, one may not initially know solution to problem;thus, development of program and research hand-in-hand
I Thus, program may need to be changed radically as a result ofexperimental evaluation: exploratory programming
I LISP is popular for exploratory programming
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 2/30
Historical Perspective
I Second oldest programming language after Fortran
I Developed in late 1950’s at MIT by John McCarthy
I Original purpose: to facilitate research in artificial intelligence
I In research, one may not initially know solution to problem;thus, development of program and research hand-in-hand
I Thus, program may need to be changed radically as a result ofexperimental evaluation: exploratory programming
I LISP is popular for exploratory programming
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 2/30
Historical Perspective
I Second oldest programming language after Fortran
I Developed in late 1950’s at MIT by John McCarthy
I Original purpose: to facilitate research in artificial intelligence
I In research, one may not initially know solution to problem;thus, development of program and research hand-in-hand
I Thus, program may need to be changed radically as a result ofexperimental evaluation: exploratory programming
I LISP is popular for exploratory programming
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 2/30
Historical Perspective
I Second oldest programming language after Fortran
I Developed in late 1950’s at MIT by John McCarthy
I Original purpose: to facilitate research in artificial intelligence
I In research, one may not initially know solution to problem;thus, development of program and research hand-in-hand
I Thus, program may need to be changed radically as a result ofexperimental evaluation: exploratory programming
I LISP is popular for exploratory programming
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 2/30
LISP, Lists, and Dialects
I The main data structures in LISP are lists
I LISP is named after its main data structure: LISt Processor
I Another feature of LISP: need to write lots of parentheses!
I Students who hate parentheses in LISP have given it manynicknames:
I ”Lost In Stupid Parentheses”
I ”Lots of Irritating Superfluous Parentheses”
I Today, there are many variations of the original LISP:Common LISP, Scheme, Clojure
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 3/30
LISP, Lists, and Dialects
I The main data structures in LISP are lists
I LISP is named after its main data structure: LISt Processor
I Another feature of LISP: need to write lots of parentheses!
I Students who hate parentheses in LISP have given it manynicknames:
I ”Lost In Stupid Parentheses”
I ”Lots of Irritating Superfluous Parentheses”
I Today, there are many variations of the original LISP:Common LISP, Scheme, Clojure
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 3/30
LISP, Lists, and Dialects
I The main data structures in LISP are lists
I LISP is named after its main data structure: LISt Processor
I Another feature of LISP: need to write lots of parentheses!
I Students who hate parentheses in LISP have given it manynicknames:
I ”Lost In Stupid Parentheses”
I ”Lots of Irritating Superfluous Parentheses”
I Today, there are many variations of the original LISP:Common LISP, Scheme, Clojure
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 3/30
LISP, Lists, and Dialects
I The main data structures in LISP are lists
I LISP is named after its main data structure: LISt Processor
I Another feature of LISP: need to write lots of parentheses!
I Students who hate parentheses in LISP have given it manynicknames:
I ”Lost In Stupid Parentheses”
I ”Lots of Irritating Superfluous Parentheses”
I Today, there are many variations of the original LISP:Common LISP, Scheme, Clojure
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 3/30
LISP, Lists, and Dialects
I The main data structures in LISP are lists
I LISP is named after its main data structure: LISt Processor
I Another feature of LISP: need to write lots of parentheses!
I Students who hate parentheses in LISP have given it manynicknames:
I ”Lost In Stupid Parentheses”
I ”Lots of Irritating Superfluous Parentheses”
I Today, there are many variations of the original LISP:Common LISP, Scheme, Clojure
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 3/30
LISP, Lists, and Dialects
I The main data structures in LISP are lists
I LISP is named after its main data structure: LISt Processor
I Another feature of LISP: need to write lots of parentheses!
I Students who hate parentheses in LISP have given it manynicknames:
I ”Lost In Stupid Parentheses”
I ”Lots of Irritating Superfluous Parentheses”
I Today, there are many variations of the original LISP:Common LISP, Scheme, Clojure
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 3/30
LISP, Lists, and Dialects
I The main data structures in LISP are lists
I LISP is named after its main data structure: LISt Processor
I Another feature of LISP: need to write lots of parentheses!
I Students who hate parentheses in LISP have given it manynicknames:
I ”Lost In Stupid Parentheses”
I ”Lots of Irritating Superfluous Parentheses”
I Today, there are many variations of the original LISP:Common LISP, Scheme, Clojure
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 3/30
Overview Of Important Ideas in LISP
I Functional, expression-based language
I Heavily influenced by lambda calculus
I First language to allow recursive and higher-order functions
I Lists are fundamental data type
I ”Programs as data:” programs and data represented same way
I Dynamic scoping (in original LISP)
I First language that has garbage collection
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 4/30
Overview Of Important Ideas in LISP
I Functional, expression-based language
I Heavily influenced by lambda calculus
I First language to allow recursive and higher-order functions
I Lists are fundamental data type
I ”Programs as data:” programs and data represented same way
I Dynamic scoping (in original LISP)
I First language that has garbage collection
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 4/30
Overview Of Important Ideas in LISP
I Functional, expression-based language
I Heavily influenced by lambda calculus
I First language to allow recursive and higher-order functions
I Lists are fundamental data type
I ”Programs as data:” programs and data represented same way
I Dynamic scoping (in original LISP)
I First language that has garbage collection
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 4/30
Overview Of Important Ideas in LISP
I Functional, expression-based language
I Heavily influenced by lambda calculus
I First language to allow recursive and higher-order functions
I Lists are fundamental data type
I ”Programs as data:” programs and data represented same way
I Dynamic scoping (in original LISP)
I First language that has garbage collection
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 4/30
Overview Of Important Ideas in LISP
I Functional, expression-based language
I Heavily influenced by lambda calculus
I First language to allow recursive and higher-order functions
I Lists are fundamental data type
I ”Programs as data:” programs and data represented same way
I Dynamic scoping (in original LISP)
I First language that has garbage collection
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 4/30
Overview Of Important Ideas in LISP
I Functional, expression-based language
I Heavily influenced by lambda calculus
I First language to allow recursive and higher-order functions
I Lists are fundamental data type
I ”Programs as data:” programs and data represented same way
I Dynamic scoping (in original LISP)
I First language that has garbage collection
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 4/30
Overview Of Important Ideas in LISP
I Functional, expression-based language
I Heavily influenced by lambda calculus
I First language to allow recursive and higher-order functions
I Lists are fundamental data type
I ”Programs as data:” programs and data represented same way
I Dynamic scoping (in original LISP)
I First language that has garbage collection
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 4/30
LISP as a Functional Language
I LISP is a functional programming language
I Characteristic of functional languages
1. No state or mutable data
2. No statements (such as assignment), only expressions!
3. Expressions have no side-effects
I You are already very familiar with a functional language: L!
I All functional languages have their roots in lambda calculus
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 5/30
LISP as a Functional Language
I LISP is a functional programming language
I Characteristic of functional languages
1. No state or mutable data
2. No statements (such as assignment), only expressions!
3. Expressions have no side-effects
I You are already very familiar with a functional language: L!
I All functional languages have their roots in lambda calculus
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 5/30
LISP as a Functional Language
I LISP is a functional programming language
I Characteristic of functional languages
1. No state or mutable data
2. No statements (such as assignment), only expressions!
3. Expressions have no side-effects
I You are already very familiar with a functional language: L!
I All functional languages have their roots in lambda calculus
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 5/30
LISP as a Functional Language
I LISP is a functional programming language
I Characteristic of functional languages
1. No state or mutable data
2. No statements (such as assignment), only expressions!
3. Expressions have no side-effects
I You are already very familiar with a functional language: L!
I All functional languages have their roots in lambda calculus
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 5/30
LISP as a Functional Language
I LISP is a functional programming language
I Characteristic of functional languages
1. No state or mutable data
2. No statements (such as assignment), only expressions!
3. Expressions have no side-effects
I You are already very familiar with a functional language: L!
I All functional languages have their roots in lambda calculus
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 5/30
LISP as a Functional Language
I LISP is a functional programming language
I Characteristic of functional languages
1. No state or mutable data
2. No statements (such as assignment), only expressions!
3. Expressions have no side-effects
I You are already very familiar with a functional language: L!
I All functional languages have their roots in lambda calculus
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 5/30
LISP as a Functional Language
I LISP is a functional programming language
I Characteristic of functional languages
1. No state or mutable data
2. No statements (such as assignment), only expressions!
3. Expressions have no side-effects
I You are already very familiar with a functional language: L!
I All functional languages have their roots in lambda calculus
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 5/30
LISP and Lambda Calculus
I Just like L and λ-calculus, Lisp also has lambda expressions!
I This is how you write a function that adds 1 to its argument:
(lambda (x) (+ x 1))
I In LISP, must write + x 1 instead of x+1 because alloperations are in prefix form (to make parsing easier!)
I This is how you write application expressions in LISP:
((lambda (x) (+ x 1)) 3)
I Evaluates to 4
I Don’t forget any of the parentheses – otherwise, won’t work!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 6/30
LISP and Lambda Calculus
I Just like L and λ-calculus, Lisp also has lambda expressions!
I This is how you write a function that adds 1 to its argument:
(lambda (x) (+ x 1))
I In LISP, must write + x 1 instead of x+1 because alloperations are in prefix form (to make parsing easier!)
I This is how you write application expressions in LISP:
((lambda (x) (+ x 1)) 3)
I Evaluates to 4
I Don’t forget any of the parentheses – otherwise, won’t work!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 6/30
LISP and Lambda Calculus
I Just like L and λ-calculus, Lisp also has lambda expressions!
I This is how you write a function that adds 1 to its argument:
(lambda (x) (+ x 1))
I In LISP, must write + x 1 instead of x+1 because alloperations are in prefix form (to make parsing easier!)
I This is how you write application expressions in LISP:
((lambda (x) (+ x 1)) 3)
I Evaluates to 4
I Don’t forget any of the parentheses – otherwise, won’t work!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 6/30
LISP and Lambda Calculus
I Just like L and λ-calculus, Lisp also has lambda expressions!
I This is how you write a function that adds 1 to its argument:
(lambda (x) (+ x 1))
I In LISP, must write + x 1 instead of x+1 because alloperations are in prefix form (to make parsing easier!)
I This is how you write application expressions in LISP:
((lambda (x) (+ x 1)) 3)
I Evaluates to 4
I Don’t forget any of the parentheses – otherwise, won’t work!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 6/30
LISP and Lambda Calculus
I Just like L and λ-calculus, Lisp also has lambda expressions!
I This is how you write a function that adds 1 to its argument:
(lambda (x) (+ x 1))
I In LISP, must write + x 1 instead of x+1 because alloperations are in prefix form (to make parsing easier!)
I This is how you write application expressions in LISP:
((lambda (x) (+ x 1)) 3)
I Evaluates to 4
I Don’t forget any of the parentheses – otherwise, won’t work!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 6/30
LISP and Lambda Calculus
I Just like L and λ-calculus, Lisp also has lambda expressions!
I This is how you write a function that adds 1 to its argument:
(lambda (x) (+ x 1))
I In LISP, must write + x 1 instead of x+1 because alloperations are in prefix form (to make parsing easier!)
I This is how you write application expressions in LISP:
((lambda (x) (+ x 1)) 3)
I Evaluates to 4
I Don’t forget any of the parentheses – otherwise, won’t work!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 6/30
Higher-Order Functions
I Just like L and λ-calculus, very easy to write higher-orderfunctions in LISP
I A higher-order function is one that takes other functions asinput or returns a function
I Here is higher-order function in LISP for composing twofunctions:
(lambda (f g) ( (lambda (x) (f(g x)))))
I This function takes as input two function f and g and anotherargument x and computes f(g(x))
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 7/30
Higher-Order Functions
I Just like L and λ-calculus, very easy to write higher-orderfunctions in LISP
I A higher-order function is one that takes other functions asinput or returns a function
I Here is higher-order function in LISP for composing twofunctions:
(lambda (f g) ( (lambda (x) (f(g x)))))
I This function takes as input two function f and g and anotherargument x and computes f(g(x))
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 7/30
Higher-Order Functions
I Just like L and λ-calculus, very easy to write higher-orderfunctions in LISP
I A higher-order function is one that takes other functions asinput or returns a function
I Here is higher-order function in LISP for composing twofunctions:
(lambda (f g) ( (lambda (x) (f(g x)))))
I This function takes as input two function f and g and anotherargument x and computes f(g(x))
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 7/30
Higher-Order Functions
I Just like L and λ-calculus, very easy to write higher-orderfunctions in LISP
I A higher-order function is one that takes other functions asinput or returns a function
I Here is higher-order function in LISP for composing twofunctions:
(lambda (f g) ( (lambda (x) (f(g x)))))
I This function takes as input two function f and g and anotherargument x and computes f(g(x))
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 7/30
Named vs. Anonymous Functions
I Lambda expressions such as (lambda (x) (+ x 1)) areanonymous functions (i.e., functions without a name)
I Like L, LISP also allows giving functions a name
I This is how you name functions in LISP:
(define compose (lambda (f g) ((lambda (x) (f(g x)))))
I You can call named functions like this:
(compose (lambda (x) (+x x)) (lambda (x) (* x x)))
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 8/30
Named vs. Anonymous Functions
I Lambda expressions such as (lambda (x) (+ x 1)) areanonymous functions (i.e., functions without a name)
I Like L, LISP also allows giving functions a name
I This is how you name functions in LISP:
(define compose (lambda (f g) ((lambda (x) (f(g x)))))
I You can call named functions like this:
(compose (lambda (x) (+x x)) (lambda (x) (* x x)))
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 8/30
Named vs. Anonymous Functions
I Lambda expressions such as (lambda (x) (+ x 1)) areanonymous functions (i.e., functions without a name)
I Like L, LISP also allows giving functions a name
I This is how you name functions in LISP:
(define compose (lambda (f g) ((lambda (x) (f(g x)))))
I You can call named functions like this:
(compose (lambda (x) (+x x)) (lambda (x) (* x x)))
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 8/30
Named vs. Anonymous Functions
I Lambda expressions such as (lambda (x) (+ x 1)) areanonymous functions (i.e., functions without a name)
I Like L, LISP also allows giving functions a name
I This is how you name functions in LISP:
(define compose (lambda (f g) ((lambda (x) (f(g x)))))
I You can call named functions like this:
(compose (lambda (x) (+x x)) (lambda (x) (* x x)))
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 8/30
Named Functions and Recursion
I As we saw in L, named functions make recursion more natural
I Here is a recursive function in LISP:
(define f (lambda (x)
(cond ((eq x 0) 0) (true + x f(- x 1))))
I This function uses a conditional expression:
(cond (p1 e1) ... (pn en))
I Here, we evaluate each condition p in order from left-to-right
I If pi is the first expression that evaluates to true, then weevaluate corresponding expression ei
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 9/30
Named Functions and Recursion
I As we saw in L, named functions make recursion more natural
I Here is a recursive function in LISP:
(define f (lambda (x)
(cond ((eq x 0) 0) (true + x f(- x 1))))
I This function uses a conditional expression:
(cond (p1 e1) ... (pn en))
I Here, we evaluate each condition p in order from left-to-right
I If pi is the first expression that evaluates to true, then weevaluate corresponding expression ei
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 9/30
Named Functions and Recursion
I As we saw in L, named functions make recursion more natural
I Here is a recursive function in LISP:
(define f (lambda (x)
(cond ((eq x 0) 0) (true + x f(- x 1))))
I This function uses a conditional expression:
(cond (p1 e1) ... (pn en))
I Here, we evaluate each condition p in order from left-to-right
I If pi is the first expression that evaluates to true, then weevaluate corresponding expression ei
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 9/30
Named Functions and Recursion
I As we saw in L, named functions make recursion more natural
I Here is a recursive function in LISP:
(define f (lambda (x)
(cond ((eq x 0) 0) (true + x f(- x 1))))
I This function uses a conditional expression:
(cond (p1 e1) ... (pn en))
I Here, we evaluate each condition p in order from left-to-right
I If pi is the first expression that evaluates to true, then weevaluate corresponding expression ei
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 9/30
Named Functions and Recursion
I As we saw in L, named functions make recursion more natural
I Here is a recursive function in LISP:
(define f (lambda (x)
(cond ((eq x 0) 0) (true + x f(- x 1))))
I This function uses a conditional expression:
(cond (p1 e1) ... (pn en))
I Here, we evaluate each condition p in order from left-to-right
I If pi is the first expression that evaluates to true, then weevaluate corresponding expression ei
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 9/30
Named Functions and Recursion
(define f (lambda (x)
(cond ((eq x 0) 0) (true + x f(- x 1))))
I The expression (eq e1 e2) evaluates to true if e1 and e2are equal, and to false otherwise
I So, what does the recursive function above compute?
I Recall: possible to encode recursion without named functions
I McCarthy’s original paper on LISP remarks that lambdaexpressions are not sufficient for writing recursive functions
I Apparently, Y-combinator not known to McCarthy and hisgroup back then – you know better!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 10/30
Named Functions and Recursion
(define f (lambda (x)
(cond ((eq x 0) 0) (true + x f(- x 1))))
I The expression (eq e1 e2) evaluates to true if e1 and e2are equal, and to false otherwise
I So, what does the recursive function above compute?
I Recall: possible to encode recursion without named functions
I McCarthy’s original paper on LISP remarks that lambdaexpressions are not sufficient for writing recursive functions
I Apparently, Y-combinator not known to McCarthy and hisgroup back then – you know better!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 10/30
Named Functions and Recursion
(define f (lambda (x)
(cond ((eq x 0) 0) (true + x f(- x 1))))
I The expression (eq e1 e2) evaluates to true if e1 and e2are equal, and to false otherwise
I So, what does the recursive function above compute?
I Recall: possible to encode recursion without named functions
I McCarthy’s original paper on LISP remarks that lambdaexpressions are not sufficient for writing recursive functions
I Apparently, Y-combinator not known to McCarthy and hisgroup back then – you know better!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 10/30
Named Functions and Recursion
(define f (lambda (x)
(cond ((eq x 0) 0) (true + x f(- x 1))))
I The expression (eq e1 e2) evaluates to true if e1 and e2are equal, and to false otherwise
I So, what does the recursive function above compute?
I Recall: possible to encode recursion without named functions
I McCarthy’s original paper on LISP remarks that lambdaexpressions are not sufficient for writing recursive functions
I Apparently, Y-combinator not known to McCarthy and hisgroup back then – you know better!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 10/30
Named Functions and Recursion
(define f (lambda (x)
(cond ((eq x 0) 0) (true + x f(- x 1))))
I The expression (eq e1 e2) evaluates to true if e1 and e2are equal, and to false otherwise
I So, what does the recursive function above compute?
I Recall: possible to encode recursion without named functions
I McCarthy’s original paper on LISP remarks that lambdaexpressions are not sufficient for writing recursive functions
I Apparently, Y-combinator not known to McCarthy and hisgroup back then – you know better!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 10/30
Atoms and Lists
I Two fundamental data types in LISP: atoms and lists
I Atoms are integers, floating point numbers and symbolicvalues, such as x
I Lists in LISP are singly-linked lists; each cell in list called cons
I A cons consists of two pointers, called car and cdr
I Can think of car as data stored in current list cell and cdr isa pointer to the rest of the list
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 11/30
Atoms and Lists
I Two fundamental data types in LISP: atoms and lists
I Atoms are integers, floating point numbers and symbolicvalues, such as x
I Lists in LISP are singly-linked lists; each cell in list called cons
I A cons consists of two pointers, called car and cdr
I Can think of car as data stored in current list cell and cdr isa pointer to the rest of the list
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 11/30
Atoms and Lists
I Two fundamental data types in LISP: atoms and lists
I Atoms are integers, floating point numbers and symbolicvalues, such as x
I Lists in LISP are singly-linked lists; each cell in list called cons
I A cons consists of two pointers, called car and cdr
I Can think of car as data stored in current list cell and cdr isa pointer to the rest of the list
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 11/30
Atoms and Lists
I Two fundamental data types in LISP: atoms and lists
I Atoms are integers, floating point numbers and symbolicvalues, such as x
I Lists in LISP are singly-linked lists; each cell in list called cons
I A cons consists of two pointers, called car and cdr
I Can think of car as data stored in current list cell and cdr isa pointer to the rest of the list
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 11/30
Atoms and Lists
I Two fundamental data types in LISP: atoms and lists
I Atoms are integers, floating point numbers and symbolicvalues, such as x
I Lists in LISP are singly-linked lists; each cell in list called cons
I A cons consists of two pointers, called car and cdr
I Can think of car as data stored in current list cell and cdr isa pointer to the rest of the list
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 11/30
List Operators
I List operations in LISP are: cons car cdr
I cons appends two lists or atoms together
I car,cdr take lists apart: car gives first elem,cdr gives rest
I nil denotes empty list
I Example: (cons 1 2 (cons 3 4)) evaluates to (1 2 (3 4))
I Example:(cons 1 2 (cdr (cons 3 4))) evaluates to (1 2 3)
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 12/30
List Operators
I List operations in LISP are: cons car cdr
I cons appends two lists or atoms together
I car,cdr take lists apart: car gives first elem,cdr gives rest
I nil denotes empty list
I Example: (cons 1 2 (cons 3 4)) evaluates to (1 2 (3 4))
I Example:(cons 1 2 (cdr (cons 3 4))) evaluates to (1 2 3)
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 12/30
List Operators
I List operations in LISP are: cons car cdr
I cons appends two lists or atoms together
I car,cdr take lists apart: car gives first elem,cdr gives rest
I nil denotes empty list
I Example: (cons 1 2 (cons 3 4)) evaluates to (1 2 (3 4))
I Example:(cons 1 2 (cdr (cons 3 4))) evaluates to (1 2 3)
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 12/30
List Operators
I List operations in LISP are: cons car cdr
I cons appends two lists or atoms together
I car,cdr take lists apart: car gives first elem,cdr gives rest
I nil denotes empty list
I Example: (cons 1 2 (cons 3 4)) evaluates to (1 2 (3 4))
I Example:(cons 1 2 (cdr (cons 3 4))) evaluates to (1 2 3)
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 12/30
List Operators
I List operations in LISP are: cons car cdr
I cons appends two lists or atoms together
I car,cdr take lists apart: car gives first elem,cdr gives rest
I nil denotes empty list
I Example: (cons 1 2 (cons 3 4)) evaluates to (1 2 (3 4))
I Example:(cons 1 2 (cdr (cons 3 4))) evaluates to (1 2 3)
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 12/30
List Operators
I List operations in LISP are: cons car cdr
I cons appends two lists or atoms together
I car,cdr take lists apart: car gives first elem,cdr gives rest
I nil denotes empty list
I Example: (cons 1 2 (cons 3 4)) evaluates to (1 2 (3 4))
I Example:(cons 1 2 (cdr (cons 3 4))) evaluates to (1 2 3)
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 12/30
Programs as Data
I In LISP, programs and data have the same internalrepresentation.
I Can write LISP programs that build data structuresrepresenting other LISP programs and evaluate them!
I There is a built-in eval function that calls the Lisp interpreterfrom the Lisp interpreter
I Example: Suppose we have read function that reads inputfrom user
I (eval (read)) executes LISP program source code enteredby user!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 13/30
Programs as Data
I In LISP, programs and data have the same internalrepresentation.
I Can write LISP programs that build data structuresrepresenting other LISP programs and evaluate them!
I There is a built-in eval function that calls the Lisp interpreterfrom the Lisp interpreter
I Example: Suppose we have read function that reads inputfrom user
I (eval (read)) executes LISP program source code enteredby user!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 13/30
Programs as Data
I In LISP, programs and data have the same internalrepresentation.
I Can write LISP programs that build data structuresrepresenting other LISP programs and evaluate them!
I There is a built-in eval function that calls the Lisp interpreterfrom the Lisp interpreter
I Example: Suppose we have read function that reads inputfrom user
I (eval (read)) executes LISP program source code enteredby user!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 13/30
Programs as Data
I In LISP, programs and data have the same internalrepresentation.
I Can write LISP programs that build data structuresrepresenting other LISP programs and evaluate them!
I There is a built-in eval function that calls the Lisp interpreterfrom the Lisp interpreter
I Example: Suppose we have read function that reads inputfrom user
I (eval (read)) executes LISP program source code enteredby user!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 13/30
Programs as Data
I In LISP, programs and data have the same internalrepresentation.
I Can write LISP programs that build data structuresrepresenting other LISP programs and evaluate them!
I There is a built-in eval function that calls the Lisp interpreterfrom the Lisp interpreter
I Example: Suppose we have read function that reads inputfrom user
I (eval (read)) executes LISP program source code enteredby user!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 13/30
Dynamic vs. Static Scoping
I The original version of LISP was dynamically scoped
I Modern LISP dialects are statically scoped (e.g., Scheme)
I Statically scoped languages use the textually closest definitionof a variable (source-code based)
I Dynamically scoped languages use the most recent run-timedefinition of a variable (run-time notion)
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 14/30
Dynamic vs. Static Scoping
I The original version of LISP was dynamically scoped
I Modern LISP dialects are statically scoped (e.g., Scheme)
I Statically scoped languages use the textually closest definitionof a variable (source-code based)
I Dynamically scoped languages use the most recent run-timedefinition of a variable (run-time notion)
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 14/30
Dynamic vs. Static Scoping
I The original version of LISP was dynamically scoped
I Modern LISP dialects are statically scoped (e.g., Scheme)
I Statically scoped languages use the textually closest definitionof a variable (source-code based)
I Dynamically scoped languages use the most recent run-timedefinition of a variable (run-time notion)
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 14/30
Dynamic vs. Static Scoping
I The original version of LISP was dynamically scoped
I Modern LISP dialects are statically scoped (e.g., Scheme)
I Statically scoped languages use the textually closest definitionof a variable (source-code based)
I Dynamically scoped languages use the most recent run-timedefinition of a variable (run-time notion)
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 14/30
Dynamic vs. Static Scoping Example
I Consider the following program:
(define h (lambda (a) (+ a 1)))
(define g (lambda (z) ( + (h 0) z))
(define f (lambda (y) (
(define h (lambda (a) (+ a 2)))
(g y))))
(f 3)
I In statically-scoped dialect of LISP, what does this programevaluate to?
4
I In dynamically-scoped LISP, what does this program evaluateto?
5
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 15/30
Dynamic vs. Static Scoping Example
I Consider the following program:
(define h (lambda (a) (+ a 1)))
(define g (lambda (z) ( + (h 0) z))
(define f (lambda (y) (
(define h (lambda (a) (+ a 2)))
(g y))))
(f 3)
I In statically-scoped dialect of LISP, what does this programevaluate to?
4
I In dynamically-scoped LISP, what does this program evaluateto?
5
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 15/30
Dynamic vs. Static Scoping Example
I Consider the following program:
(define h (lambda (a) (+ a 1)))
(define g (lambda (z) ( + (h 0) z))
(define f (lambda (y) (
(define h (lambda (a) (+ a 2)))
(g y))))
(f 3)
I In statically-scoped dialect of LISP, what does this programevaluate to? 4
I In dynamically-scoped LISP, what does this program evaluateto?
5
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 15/30
Dynamic vs. Static Scoping Example
I Consider the following program:
(define h (lambda (a) (+ a 1)))
(define g (lambda (z) ( + (h 0) z))
(define f (lambda (y) (
(define h (lambda (a) (+ a 2)))
(g y))))
(f 3)
I In statically-scoped dialect of LISP, what does this programevaluate to? 4
I In dynamically-scoped LISP, what does this program evaluateto?
5
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 15/30
Dynamic vs. Static Scoping Example
I Consider the following program:
(define h (lambda (a) (+ a 1)))
(define g (lambda (z) ( + (h 0) z))
(define f (lambda (y) (
(define h (lambda (a) (+ a 2)))
(g y))))
(f 3)
I In statically-scoped dialect of LISP, what does this programevaluate to? 4
I In dynamically-scoped LISP, what does this program evaluateto? 5
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 15/30
Garbage Collection
I LISP is the first programming language that had the idea ofgarbage collection
I A memory location is garbage if it can no longer be accessedby the program
I If a memory location is garbage, changing the value stored inthat location cannot change the result of the program
I Thus, if we had a way of finding all memory locations that aregarbage, we could reclaim those memory locations and usethem for some other purpose
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 16/30
Garbage Collection
I LISP is the first programming language that had the idea ofgarbage collection
I A memory location is garbage if it can no longer be accessedby the program
I If a memory location is garbage, changing the value stored inthat location cannot change the result of the program
I Thus, if we had a way of finding all memory locations that aregarbage, we could reclaim those memory locations and usethem for some other purpose
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 16/30
Garbage Collection
I LISP is the first programming language that had the idea ofgarbage collection
I A memory location is garbage if it can no longer be accessedby the program
I If a memory location is garbage, changing the value stored inthat location cannot change the result of the program
I Thus, if we had a way of finding all memory locations that aregarbage, we could reclaim those memory locations and usethem for some other purpose
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 16/30
Garbage Collection
I LISP is the first programming language that had the idea ofgarbage collection
I A memory location is garbage if it can no longer be accessedby the program
I If a memory location is garbage, changing the value stored inthat location cannot change the result of the program
I Thus, if we had a way of finding all memory locations that aregarbage, we could reclaim those memory locations and usethem for some other purpose
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 16/30
Explicit vs. Automatic Memory Management
I Garbage collection is the task of detecting garbage during theexecution of a program and reclaiming this unused memory
I Operating system keeps a list of available memory called thefree list
I In languages that are not garbage-collected (e.g., C)programmer must explicitly call free to deallocate an unusedmemory location
I In garbage-collected languages like LISP and Java, theprogrammer does not need to worry about deallocatingmemory – this is done automatically by the run-time system
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 17/30
Explicit vs. Automatic Memory Management
I Garbage collection is the task of detecting garbage during theexecution of a program and reclaiming this unused memory
I Operating system keeps a list of available memory called thefree list
I In languages that are not garbage-collected (e.g., C)programmer must explicitly call free to deallocate an unusedmemory location
I In garbage-collected languages like LISP and Java, theprogrammer does not need to worry about deallocatingmemory – this is done automatically by the run-time system
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 17/30
Explicit vs. Automatic Memory Management
I Garbage collection is the task of detecting garbage during theexecution of a program and reclaiming this unused memory
I Operating system keeps a list of available memory called thefree list
I In languages that are not garbage-collected (e.g., C)programmer must explicitly call free to deallocate an unusedmemory location
I In garbage-collected languages like LISP and Java, theprogrammer does not need to worry about deallocatingmemory – this is done automatically by the run-time system
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 17/30
Explicit vs. Automatic Memory Management
I Garbage collection is the task of detecting garbage during theexecution of a program and reclaiming this unused memory
I Operating system keeps a list of available memory called thefree list
I In languages that are not garbage-collected (e.g., C)programmer must explicitly call free to deallocate an unusedmemory location
I In garbage-collected languages like LISP and Java, theprogrammer does not need to worry about deallocatingmemory – this is done automatically by the run-time system
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 17/30
Advantages of Garbage Collection
I Garbage collection makes programming much easier!
I In explicitly-memory managed languages, programmer musttrack which memory locations are unused
I Explicit memory management constant source of headaches:
I Memory leaks: forgetting to delete unused memory)
I Dangling pointers: deleting memory that’s still in use
I In automatically memory-managed languages like LISP andJava, such errors are not possible!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 18/30
Advantages of Garbage Collection
I Garbage collection makes programming much easier!
I In explicitly-memory managed languages, programmer musttrack which memory locations are unused
I Explicit memory management constant source of headaches:
I Memory leaks: forgetting to delete unused memory)
I Dangling pointers: deleting memory that’s still in use
I In automatically memory-managed languages like LISP andJava, such errors are not possible!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 18/30
Advantages of Garbage Collection
I Garbage collection makes programming much easier!
I In explicitly-memory managed languages, programmer musttrack which memory locations are unused
I Explicit memory management constant source of headaches:
I Memory leaks: forgetting to delete unused memory)
I Dangling pointers: deleting memory that’s still in use
I In automatically memory-managed languages like LISP andJava, such errors are not possible!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 18/30
Advantages of Garbage Collection
I Garbage collection makes programming much easier!
I In explicitly-memory managed languages, programmer musttrack which memory locations are unused
I Explicit memory management constant source of headaches:
I Memory leaks: forgetting to delete unused memory)
I Dangling pointers: deleting memory that’s still in use
I In automatically memory-managed languages like LISP andJava, such errors are not possible!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 18/30
Advantages of Garbage Collection
I Garbage collection makes programming much easier!
I In explicitly-memory managed languages, programmer musttrack which memory locations are unused
I Explicit memory management constant source of headaches:
I Memory leaks: forgetting to delete unused memory)
I Dangling pointers: deleting memory that’s still in use
I In automatically memory-managed languages like LISP andJava, such errors are not possible!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 18/30
Advantages of Garbage Collection
I Garbage collection makes programming much easier!
I In explicitly-memory managed languages, programmer musttrack which memory locations are unused
I Explicit memory management constant source of headaches:
I Memory leaks: forgetting to delete unused memory)
I Dangling pointers: deleting memory that’s still in use
I In automatically memory-managed languages like LISP andJava, such errors are not possible!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 18/30
Disadvantages of Garbage Collection
I Potential disadvantage of garbage collection is overhead
I In automatically garbage-collected languages, we must dowork at run-time to figure out what is garbage
I Identifying what is garbage and reclaiming it takes time; thus,there is a performance penalty
I While the garbage collector is running, program can feelsluggish, unresponsive
I But for many programmers, this is a small price to pay forinconvenience of manually managing memory
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 19/30
Disadvantages of Garbage Collection
I Potential disadvantage of garbage collection is overhead
I In automatically garbage-collected languages, we must dowork at run-time to figure out what is garbage
I Identifying what is garbage and reclaiming it takes time; thus,there is a performance penalty
I While the garbage collector is running, program can feelsluggish, unresponsive
I But for many programmers, this is a small price to pay forinconvenience of manually managing memory
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 19/30
Disadvantages of Garbage Collection
I Potential disadvantage of garbage collection is overhead
I In automatically garbage-collected languages, we must dowork at run-time to figure out what is garbage
I Identifying what is garbage and reclaiming it takes time; thus,there is a performance penalty
I While the garbage collector is running, program can feelsluggish, unresponsive
I But for many programmers, this is a small price to pay forinconvenience of manually managing memory
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 19/30
Disadvantages of Garbage Collection
I Potential disadvantage of garbage collection is overhead
I In automatically garbage-collected languages, we must dowork at run-time to figure out what is garbage
I Identifying what is garbage and reclaiming it takes time; thus,there is a performance penalty
I While the garbage collector is running, program can feelsluggish, unresponsive
I But for many programmers, this is a small price to pay forinconvenience of manually managing memory
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 19/30
Disadvantages of Garbage Collection
I Potential disadvantage of garbage collection is overhead
I In automatically garbage-collected languages, we must dowork at run-time to figure out what is garbage
I Identifying what is garbage and reclaiming it takes time; thus,there is a performance penalty
I While the garbage collector is running, program can feelsluggish, unresponsive
I But for many programmers, this is a small price to pay forinconvenience of manually managing memory
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 19/30
How Does Garbage Collection Work?
I In past few decades, lots of research on garbage collection
I Original LISP garbage collector used simple algorithm calledMark-and-Sweep
I In Mark-and-Sweep, we reserve a bit for each memory cell,called tag bit, to identify whether it is accessible
I If tag bit is 1, means cell is in use; if it is 0, it’s unused
I Mark-and-Sweep has two phases, called mark and sweep
I In mark phase, garbage collector sets tag bits
I In sweep phase, garbage collector reclaims cells with tag bit 0
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 20/30
How Does Garbage Collection Work?
I In past few decades, lots of research on garbage collection
I Original LISP garbage collector used simple algorithm calledMark-and-Sweep
I In Mark-and-Sweep, we reserve a bit for each memory cell,called tag bit, to identify whether it is accessible
I If tag bit is 1, means cell is in use; if it is 0, it’s unused
I Mark-and-Sweep has two phases, called mark and sweep
I In mark phase, garbage collector sets tag bits
I In sweep phase, garbage collector reclaims cells with tag bit 0
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 20/30
How Does Garbage Collection Work?
I In past few decades, lots of research on garbage collection
I Original LISP garbage collector used simple algorithm calledMark-and-Sweep
I In Mark-and-Sweep, we reserve a bit for each memory cell,called tag bit, to identify whether it is accessible
I If tag bit is 1, means cell is in use; if it is 0, it’s unused
I Mark-and-Sweep has two phases, called mark and sweep
I In mark phase, garbage collector sets tag bits
I In sweep phase, garbage collector reclaims cells with tag bit 0
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 20/30
How Does Garbage Collection Work?
I In past few decades, lots of research on garbage collection
I Original LISP garbage collector used simple algorithm calledMark-and-Sweep
I In Mark-and-Sweep, we reserve a bit for each memory cell,called tag bit, to identify whether it is accessible
I If tag bit is 1, means cell is in use; if it is 0, it’s unused
I Mark-and-Sweep has two phases, called mark and sweep
I In mark phase, garbage collector sets tag bits
I In sweep phase, garbage collector reclaims cells with tag bit 0
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 20/30
How Does Garbage Collection Work?
I In past few decades, lots of research on garbage collection
I Original LISP garbage collector used simple algorithm calledMark-and-Sweep
I In Mark-and-Sweep, we reserve a bit for each memory cell,called tag bit, to identify whether it is accessible
I If tag bit is 1, means cell is in use; if it is 0, it’s unused
I Mark-and-Sweep has two phases, called mark and sweep
I In mark phase, garbage collector sets tag bits
I In sweep phase, garbage collector reclaims cells with tag bit 0
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 20/30
How Does Garbage Collection Work?
I In past few decades, lots of research on garbage collection
I Original LISP garbage collector used simple algorithm calledMark-and-Sweep
I In Mark-and-Sweep, we reserve a bit for each memory cell,called tag bit, to identify whether it is accessible
I If tag bit is 1, means cell is in use; if it is 0, it’s unused
I Mark-and-Sweep has two phases, called mark and sweep
I In mark phase, garbage collector sets tag bits
I In sweep phase, garbage collector reclaims cells with tag bit 0
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 20/30
How Does Garbage Collection Work?
I In past few decades, lots of research on garbage collection
I Original LISP garbage collector used simple algorithm calledMark-and-Sweep
I In Mark-and-Sweep, we reserve a bit for each memory cell,called tag bit, to identify whether it is accessible
I If tag bit is 1, means cell is in use; if it is 0, it’s unused
I Mark-and-Sweep has two phases, called mark and sweep
I In mark phase, garbage collector sets tag bits
I In sweep phase, garbage collector reclaims cells with tag bit 0
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 20/30
Mark-and-Sweep
I When memory is low, garbage collector initializes tag bits ofall memory cells to 0
I Then, identifies all memory locations directly used in theprogram, called root nodes
I Starting from root nodes, we follow all links (i.e., pointers)and change tag bit of each location we accessed to 1
I This is all there is to the mark phase
I In the sweep phase, we check tag bit of each memory cell
I If tag bit of that cell is 0, we add that cell to the free list
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 21/30
Mark-and-Sweep
I When memory is low, garbage collector initializes tag bits ofall memory cells to 0
I Then, identifies all memory locations directly used in theprogram, called root nodes
I Starting from root nodes, we follow all links (i.e., pointers)and change tag bit of each location we accessed to 1
I This is all there is to the mark phase
I In the sweep phase, we check tag bit of each memory cell
I If tag bit of that cell is 0, we add that cell to the free list
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 21/30
Mark-and-Sweep
I When memory is low, garbage collector initializes tag bits ofall memory cells to 0
I Then, identifies all memory locations directly used in theprogram, called root nodes
I Starting from root nodes, we follow all links (i.e., pointers)and change tag bit of each location we accessed to 1
I This is all there is to the mark phase
I In the sweep phase, we check tag bit of each memory cell
I If tag bit of that cell is 0, we add that cell to the free list
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 21/30
Mark-and-Sweep
I When memory is low, garbage collector initializes tag bits ofall memory cells to 0
I Then, identifies all memory locations directly used in theprogram, called root nodes
I Starting from root nodes, we follow all links (i.e., pointers)and change tag bit of each location we accessed to 1
I This is all there is to the mark phase
I In the sweep phase, we check tag bit of each memory cell
I If tag bit of that cell is 0, we add that cell to the free list
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 21/30
Mark-and-Sweep
I When memory is low, garbage collector initializes tag bits ofall memory cells to 0
I Then, identifies all memory locations directly used in theprogram, called root nodes
I Starting from root nodes, we follow all links (i.e., pointers)and change tag bit of each location we accessed to 1
I This is all there is to the mark phase
I In the sweep phase, we check tag bit of each memory cell
I If tag bit of that cell is 0, we add that cell to the free list
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 21/30
Mark-and-Sweep
I When memory is low, garbage collector initializes tag bits ofall memory cells to 0
I Then, identifies all memory locations directly used in theprogram, called root nodes
I Starting from root nodes, we follow all links (i.e., pointers)and change tag bit of each location we accessed to 1
I This is all there is to the mark phase
I In the sweep phase, we check tag bit of each memory cell
I If tag bit of that cell is 0, we add that cell to the free list
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 21/30
Stop the World Collectors
I Mark-and-sweep is easy to understand, easy to implement
I But it stops the world: while garbage collector is running,nothing else can happen
I As a result, program is unresponsive while collector is running
I People have come up with much more sophisticated garbagecollection algorithms
I Concurrent garbage collectors run concurrently with theprogram – they don’t “stop the world”
I But much more difficult to implement and get right – cellscan become reachable while collector is running!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 22/30
Stop the World Collectors
I Mark-and-sweep is easy to understand, easy to implement
I But it stops the world: while garbage collector is running,nothing else can happen
I As a result, program is unresponsive while collector is running
I People have come up with much more sophisticated garbagecollection algorithms
I Concurrent garbage collectors run concurrently with theprogram – they don’t “stop the world”
I But much more difficult to implement and get right – cellscan become reachable while collector is running!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 22/30
Stop the World Collectors
I Mark-and-sweep is easy to understand, easy to implement
I But it stops the world: while garbage collector is running,nothing else can happen
I As a result, program is unresponsive while collector is running
I People have come up with much more sophisticated garbagecollection algorithms
I Concurrent garbage collectors run concurrently with theprogram – they don’t “stop the world”
I But much more difficult to implement and get right – cellscan become reachable while collector is running!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 22/30
Stop the World Collectors
I Mark-and-sweep is easy to understand, easy to implement
I But it stops the world: while garbage collector is running,nothing else can happen
I As a result, program is unresponsive while collector is running
I People have come up with much more sophisticated garbagecollection algorithms
I Concurrent garbage collectors run concurrently with theprogram – they don’t “stop the world”
I But much more difficult to implement and get right – cellscan become reachable while collector is running!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 22/30
Stop the World Collectors
I Mark-and-sweep is easy to understand, easy to implement
I But it stops the world: while garbage collector is running,nothing else can happen
I As a result, program is unresponsive while collector is running
I People have come up with much more sophisticated garbagecollection algorithms
I Concurrent garbage collectors run concurrently with theprogram – they don’t “stop the world”
I But much more difficult to implement and get right – cellscan become reachable while collector is running!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 22/30
Stop the World Collectors
I Mark-and-sweep is easy to understand, easy to implement
I But it stops the world: while garbage collector is running,nothing else can happen
I As a result, program is unresponsive while collector is running
I People have come up with much more sophisticated garbagecollection algorithms
I Concurrent garbage collectors run concurrently with theprogram – they don’t “stop the world”
I But much more difficult to implement and get right – cellscan become reachable while collector is running!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 22/30
LISP and Garbage Collection
I LISP was first automatically garbage-collected language
I This idea has been extremely influential
I Almost any modern language invented today is automaticallymemory managed
I However, garbage collection does not eliminate all headaches
I It is still possible to leak memory
I If you leave references (i.e. pointers) to memory cells thatprogram won’t use, you can still leak memory
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 23/30
LISP and Garbage Collection
I LISP was first automatically garbage-collected language
I This idea has been extremely influential
I Almost any modern language invented today is automaticallymemory managed
I However, garbage collection does not eliminate all headaches
I It is still possible to leak memory
I If you leave references (i.e. pointers) to memory cells thatprogram won’t use, you can still leak memory
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 23/30
LISP and Garbage Collection
I LISP was first automatically garbage-collected language
I This idea has been extremely influential
I Almost any modern language invented today is automaticallymemory managed
I However, garbage collection does not eliminate all headaches
I It is still possible to leak memory
I If you leave references (i.e. pointers) to memory cells thatprogram won’t use, you can still leak memory
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 23/30
LISP and Garbage Collection
I LISP was first automatically garbage-collected language
I This idea has been extremely influential
I Almost any modern language invented today is automaticallymemory managed
I However, garbage collection does not eliminate all headaches
I It is still possible to leak memory
I If you leave references (i.e. pointers) to memory cells thatprogram won’t use, you can still leak memory
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 23/30
LISP and Garbage Collection
I LISP was first automatically garbage-collected language
I This idea has been extremely influential
I Almost any modern language invented today is automaticallymemory managed
I However, garbage collection does not eliminate all headaches
I It is still possible to leak memory
I If you leave references (i.e. pointers) to memory cells thatprogram won’t use, you can still leak memory
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 23/30
LISP and Garbage Collection
I LISP was first automatically garbage-collected language
I This idea has been extremely influential
I Almost any modern language invented today is automaticallymemory managed
I However, garbage collection does not eliminate all headaches
I It is still possible to leak memory
I If you leave references (i.e. pointers) to memory cells thatprogram won’t use, you can still leak memory
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 23/30
Pure vs. Impure LISP
I The part of LISP we talked about so far is a pure functionallanguage
I Pure functional language means expressions do not have sideeffects
I However, for performance/efficiency reasons, it might bedesirable to modify data
I For example, suppose you need to change value of oneelement in a list
I In pure LISP, only way to do this is to create a new list that isidentical to old one except for one cell
I But this can be very inefficient
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 24/30
Pure vs. Impure LISP
I The part of LISP we talked about so far is a pure functionallanguage
I Pure functional language means expressions do not have sideeffects
I However, for performance/efficiency reasons, it might bedesirable to modify data
I For example, suppose you need to change value of oneelement in a list
I In pure LISP, only way to do this is to create a new list that isidentical to old one except for one cell
I But this can be very inefficient
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 24/30
Pure vs. Impure LISP
I The part of LISP we talked about so far is a pure functionallanguage
I Pure functional language means expressions do not have sideeffects
I However, for performance/efficiency reasons, it might bedesirable to modify data
I For example, suppose you need to change value of oneelement in a list
I In pure LISP, only way to do this is to create a new list that isidentical to old one except for one cell
I But this can be very inefficient
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 24/30
Pure vs. Impure LISP
I The part of LISP we talked about so far is a pure functionallanguage
I Pure functional language means expressions do not have sideeffects
I However, for performance/efficiency reasons, it might bedesirable to modify data
I For example, suppose you need to change value of oneelement in a list
I In pure LISP, only way to do this is to create a new list that isidentical to old one except for one cell
I But this can be very inefficient
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 24/30
Pure vs. Impure LISP
I The part of LISP we talked about so far is a pure functionallanguage
I Pure functional language means expressions do not have sideeffects
I However, for performance/efficiency reasons, it might bedesirable to modify data
I For example, suppose you need to change value of oneelement in a list
I In pure LISP, only way to do this is to create a new list that isidentical to old one except for one cell
I But this can be very inefficient
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 24/30
Pure vs. Impure LISP
I The part of LISP we talked about so far is a pure functionallanguage
I Pure functional language means expressions do not have sideeffects
I However, for performance/efficiency reasons, it might bedesirable to modify data
I For example, suppose you need to change value of oneelement in a list
I In pure LISP, only way to do this is to create a new list that isidentical to old one except for one cell
I But this can be very inefficient
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 24/30
Impure Features of LISP
I Thus, many functional programming languages have anescape hatch to allow modifying data/state
I Even early versions of LISP had some impure expressionswhich can have side effects
I Two notable impure expressions in LISP, rplaca and rplacd
I (rplaca x y) replaces car field of cons cell x with y
I (rplacd x y) replaces cdr field of cons cell x with y
I Example: rplaca (cons 1 2) 3) yields the list (1 3)
I However, we haven’t allocated any new memory – justmodified existing cons cell
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 25/30
Impure Features of LISP
I Thus, many functional programming languages have anescape hatch to allow modifying data/state
I Even early versions of LISP had some impure expressionswhich can have side effects
I Two notable impure expressions in LISP, rplaca and rplacd
I (rplaca x y) replaces car field of cons cell x with y
I (rplacd x y) replaces cdr field of cons cell x with y
I Example: rplaca (cons 1 2) 3) yields the list (1 3)
I However, we haven’t allocated any new memory – justmodified existing cons cell
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 25/30
Impure Features of LISP
I Thus, many functional programming languages have anescape hatch to allow modifying data/state
I Even early versions of LISP had some impure expressionswhich can have side effects
I Two notable impure expressions in LISP, rplaca and rplacd
I (rplaca x y) replaces car field of cons cell x with y
I (rplacd x y) replaces cdr field of cons cell x with y
I Example: rplaca (cons 1 2) 3) yields the list (1 3)
I However, we haven’t allocated any new memory – justmodified existing cons cell
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 25/30
Impure Features of LISP
I Thus, many functional programming languages have anescape hatch to allow modifying data/state
I Even early versions of LISP had some impure expressionswhich can have side effects
I Two notable impure expressions in LISP, rplaca and rplacd
I (rplaca x y) replaces car field of cons cell x with y
I (rplacd x y) replaces cdr field of cons cell x with y
I Example: rplaca (cons 1 2) 3) yields the list (1 3)
I However, we haven’t allocated any new memory – justmodified existing cons cell
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 25/30
Impure Features of LISP
I Thus, many functional programming languages have anescape hatch to allow modifying data/state
I Even early versions of LISP had some impure expressionswhich can have side effects
I Two notable impure expressions in LISP, rplaca and rplacd
I (rplaca x y) replaces car field of cons cell x with y
I (rplacd x y) replaces cdr field of cons cell x with y
I Example: rplaca (cons 1 2) 3) yields the list (1 3)
I However, we haven’t allocated any new memory – justmodified existing cons cell
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 25/30
Impure Features of LISP
I Thus, many functional programming languages have anescape hatch to allow modifying data/state
I Even early versions of LISP had some impure expressionswhich can have side effects
I Two notable impure expressions in LISP, rplaca and rplacd
I (rplaca x y) replaces car field of cons cell x with y
I (rplacd x y) replaces cdr field of cons cell x with y
I Example: rplaca (cons 1 2) 3) yields the list (1 3)
I However, we haven’t allocated any new memory – justmodified existing cons cell
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 25/30
Impure Features of LISP
I Thus, many functional programming languages have anescape hatch to allow modifying data/state
I Even early versions of LISP had some impure expressionswhich can have side effects
I Two notable impure expressions in LISP, rplaca and rplacd
I (rplaca x y) replaces car field of cons cell x with y
I (rplacd x y) replaces cdr field of cons cell x with y
I Example: rplaca (cons 1 2) 3) yields the list (1 3)
I However, we haven’t allocated any new memory – justmodified existing cons cell
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 25/30
Quoted Expressions
I Another interesting feature of LISP is that programmer hasthe freedom to decide whether an expression should beevaluated or not
I If you quote an expression, written ‘e, this means do notevaluate this expression
I For example, if you type +1 2, this expression evaluates to 3.
I But if you write ‘(+ 1 2), it evaluates to + 1 2
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 26/30
Quoted Expressions
I Another interesting feature of LISP is that programmer hasthe freedom to decide whether an expression should beevaluated or not
I If you quote an expression, written ‘e, this means do notevaluate this expression
I For example, if you type +1 2, this expression evaluates to 3.
I But if you write ‘(+ 1 2), it evaluates to + 1 2
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 26/30
Quoted Expressions
I Another interesting feature of LISP is that programmer hasthe freedom to decide whether an expression should beevaluated or not
I If you quote an expression, written ‘e, this means do notevaluate this expression
I For example, if you type +1 2, this expression evaluates to 3.
I But if you write ‘(+ 1 2), it evaluates to + 1 2
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 26/30
Quoted Expressions
I Another interesting feature of LISP is that programmer hasthe freedom to decide whether an expression should beevaluated or not
I If you quote an expression, written ‘e, this means do notevaluate this expression
I For example, if you type +1 2, this expression evaluates to 3.
I But if you write ‘(+ 1 2), it evaluates to + 1 2
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 26/30
Summary of LISP’s Notable Features
I Father of all functional programming languages
I Supports recursion, higher-order functions, and anonymousfunctions (lambda expressions)
I Programs and data have same representation: can build datastructures representing LISP programs at run-time andevaluate them
I Introduced idea of garbage collection
I All in all, successful and very influential programming language
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 27/30
Summary of LISP’s Notable Features
I Father of all functional programming languages
I Supports recursion, higher-order functions, and anonymousfunctions (lambda expressions)
I Programs and data have same representation: can build datastructures representing LISP programs at run-time andevaluate them
I Introduced idea of garbage collection
I All in all, successful and very influential programming language
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 27/30
Summary of LISP’s Notable Features
I Father of all functional programming languages
I Supports recursion, higher-order functions, and anonymousfunctions (lambda expressions)
I Programs and data have same representation: can build datastructures representing LISP programs at run-time andevaluate them
I Introduced idea of garbage collection
I All in all, successful and very influential programming language
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 27/30
Summary of LISP’s Notable Features
I Father of all functional programming languages
I Supports recursion, higher-order functions, and anonymousfunctions (lambda expressions)
I Programs and data have same representation: can build datastructures representing LISP programs at run-time andevaluate them
I Introduced idea of garbage collection
I All in all, successful and very influential programming language
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 27/30
Summary of LISP’s Notable Features
I Father of all functional programming languages
I Supports recursion, higher-order functions, and anonymousfunctions (lambda expressions)
I Programs and data have same representation: can build datastructures representing LISP programs at run-time andevaluate them
I Introduced idea of garbage collection
I All in all, successful and very influential programming language
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 27/30
Influences of LISP
I LISP has had a lot of influence on many functionalprogramming languages today
I Design of ML, Haskell, and many other functional languagesinfluenced by LISP
I However, arguably LISP does not have the nicest syntax –parentheses and prefix-notation are quite cumbersome
I Despite this, some wide-used software written in LISP
I For instance, popular text editor emacs is written in LISP aswell as Linux graphical toolkit gtk
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 28/30
Influences of LISP
I LISP has had a lot of influence on many functionalprogramming languages today
I Design of ML, Haskell, and many other functional languagesinfluenced by LISP
I However, arguably LISP does not have the nicest syntax –parentheses and prefix-notation are quite cumbersome
I Despite this, some wide-used software written in LISP
I For instance, popular text editor emacs is written in LISP aswell as Linux graphical toolkit gtk
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 28/30
Influences of LISP
I LISP has had a lot of influence on many functionalprogramming languages today
I Design of ML, Haskell, and many other functional languagesinfluenced by LISP
I However, arguably LISP does not have the nicest syntax –parentheses and prefix-notation are quite cumbersome
I Despite this, some wide-used software written in LISP
I For instance, popular text editor emacs is written in LISP aswell as Linux graphical toolkit gtk
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 28/30
Influences of LISP
I LISP has had a lot of influence on many functionalprogramming languages today
I Design of ML, Haskell, and many other functional languagesinfluenced by LISP
I However, arguably LISP does not have the nicest syntax –parentheses and prefix-notation are quite cumbersome
I Despite this, some wide-used software written in LISP
I For instance, popular text editor emacs is written in LISP aswell as Linux graphical toolkit gtk
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 28/30
Influences of LISP
I LISP has had a lot of influence on many functionalprogramming languages today
I Design of ML, Haskell, and many other functional languagesinfluenced by LISP
I However, arguably LISP does not have the nicest syntax –parentheses and prefix-notation are quite cumbersome
I Despite this, some wide-used software written in LISP
I For instance, popular text editor emacs is written in LISP aswell as Linux graphical toolkit gtk
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 28/30
L and LISP
I Our course language L is very similar to LISP, but with nicersyntax
I In L, parantheses are not as cumbersome and allows infixnotation
I Also, we also added a static type system and type inference
I You’ve already implemented an interpreter for a LISP-likefunctional language!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 29/30
L and LISP
I Our course language L is very similar to LISP, but with nicersyntax
I In L, parantheses are not as cumbersome and allows infixnotation
I Also, we also added a static type system and type inference
I You’ve already implemented an interpreter for a LISP-likefunctional language!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 29/30
L and LISP
I Our course language L is very similar to LISP, but with nicersyntax
I In L, parantheses are not as cumbersome and allows infixnotation
I Also, we also added a static type system and type inference
I You’ve already implemented an interpreter for a LISP-likefunctional language!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 29/30
L and LISP
I Our course language L is very similar to LISP, but with nicersyntax
I In L, parantheses are not as cumbersome and allows infixnotation
I Also, we also added a static type system and type inference
I You’ve already implemented an interpreter for a LISP-likefunctional language!
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 29/30
A Funny Quote
”A LISP programmer knows the value of everything,but the cost of nothing”
-Alan Perlis
Thomas Dillig, CS345H: Programming Languages Lecture: LISP 30/30