with Programming State & Golden Ages
#1
One-Slide Summary
The substitution model for evaluating Scheme does not allow us to reason about mutation. In the environment model: A name is a place for storing a value. define, cons and function application create places. set! changes the value in a place. Places live in frames. An environment is a frame and a pointer to a parent frame. The global environment has no parent. To evaluate a name, walk up the frames until you find a definition. A golden age is a period when knowledge or quality increases rapidly. #2
From Lecture 3:
Outline
Names and Places set! and friends Environment Model Golden Ages
Evaluation Rule 2: Names
If the expression is a name, it evaluates to the value associated with that name.
Interested in random weekly emails about available CS 150 tutoring? Send email to the course staff (or me) to get on that list. There will not be normally scheduled lab hours or office hours over spring break. Your Exam 1 grade will be visible on the Automatic Adjudication website.
> (define two 2) > two 2
This is called the substitution model. You can reason about Scheme expressions by substituting the definition in whenever it is used.
#3 #4
Names and Places
A name is not just a value, it is a place for storing a value. define creates a new place, associates a name with that place, and stores a value in that place
Bang!
set! ("set bang") changes the value associated with a place
(define x 3)
x: 3
#5
> (define x 3) >x 3 > (set! x 7) >x 7
x: 7 3
#6
set! should make you nervous
> (define x 2) > (nextx) Before set! all procedures 3 were pure functions (except > (nextx) for some with side-effects). 4 The value of (f) was the >x same every time you 4 evaluated it. Now it might be different!
#7
Defining nextx
(define (nextx) (set! x (+ x 1)) x)
syntactic sugar for
(define nextx (lambda () (begin (set! x (+ x 1)) x))))
#8
Evaluation Rules
Evaluation Rules
> (define x 3) > (+ (nextx) x) 7 or 8
> (+ x (nextx)) 9 or 10
> (define x 3) > (+ (nextx) x) 7 or 8
> (+ x (nextx)) 9 or 10
#9
DrScheme evaluates application subexpressions left to right, but Scheme evaluation rules allow any order.
#10
set-car! and set-cdr!
(set-car! p v) Replaces the car of the cons p with v. (set-cdr! p v) Replaces the cdr of the cons p with v. These should scare you even more then set! !
#11
> (define pair (cons 1 2)) > pair (1 . 2)
pair:
1
2
#12
> (define pair (cons 1 2)) > pair (1 . 2) > (set-car! pair 0) > (car pair) 0 > (cdr pair) 2
pair:
1 0
2
> (define pair (cons 1 2)) > pair (1 . 2) > (set-car! pair 0) > (car pair) 0 > (cdr pair) 2 > (set-cdr! pair 1) > pair (0 . 1)
pair:
1 0
2 1
#13
#14
Functional vs. Imperative
Functional Solution: A procedure that takes a procedure of one argument and a list, and returns a list of the results produced by applying the procedure to each element in the list.
Imperative Solution
(define (map proc lst) (if (null? lst) null (cons (proc (car lst)) (map proc (cdr lst)))))
A procedure that takes a procedure and list as arguments, and replaces each element in the list with the value of the procedure applied to that element.
(define (map proc lst) (if (null? lst) null (cons (proc (car lst)) (map proc (cdr lst)))))
#15
(define (map! f lst) (if (null? lst) (void) (begin (set-car! lst (f (car lst))) (map! f (cdr lst)))))
#16
Programming with Mutation
> (map! square (intsto 4)) > (define i4 (intsto 4)) > (map! square i4) > i4 (1 4 9 16) > (define i4 (intsto 4)) > (map square i4) (1 4 9 16) > i4 (1 2 3 4) Imperative Functional
#17
Mutation Changes Everything!
We can no longer talk about the "value of an expression"
The value of a give expression can change! We need to talk about "the value of an expression in an execution environment"
"execution environment" = "context so far"
The order in which expressions are evaluated now matters
#18
Why Substitution Fails
> (define (nextx) (set! x (+ x 1)) x) > (define x 0) > ((lambda (x) (+ x x)) (nextx)) 2
Substitution model for evaluation would predict:
Liberal Arts Trivia: Astrophysics
According to this 1915 theory (be specific), the observed gravitational attraction between masses results from the warping of space and time by those masses. This theory helps to explain observed phenomena, such as anomalies in the orbit of Mercury, that are not predicted by Newton's Laws, and can deal with accelerated reference frames. It is part of the framework of the standard Big Bang model of Cosmology.
#19 #20
(+ (nextx) (nextx)) (+ (begin (set! x (+ x 1)) x) (begin (set! x (+ x 1)) x)) (+ (begin (set! 0 (+ 0 1)) 0) (begin (set! 0 (+ 0 1)) 0)) (+ 0 0) 0
Liberal Arts Trivia: Rhetoric
This type of "values" debate traditionally places a heavy emphasis on logic, ethical values and philosophy. It is a one-on-one debate practiced in National Forensic League competitions. The format was named for the series of seven debates in 1858 for the Illinois seat in the United State Senate.
#21
Very Scary!
The old substitution model does not explain Scheme programs that contain mutation. We need a new environment model.
#22
Names and Places
A name is a place for storing a value. define creates a new place cons creates two new places, the car and the cdr (set! name expr) changes the value in the place name to the value of expr (set-car! pair expr) changes the value in the car place of pair to the value of expr
Lambda and Places
(lambda (x) ...) also creates a new place named x The passed argument is put in that place
> (define x 3) > ((lambda (x) x) 4) 4 >x 3
x:3 x:4
How are these places different?
#24
#23
Location, Location, Location
Places live in frames An environment is a frame and a pointer to a parent environment All environments except the global environment have exactly one parent environment, global environment has no parent Application creates a new environment
#25
Environments
global environment + : #<primitive:+> null? : #<primitive:null?>
The global environment points to the outermost frame. It starts with all Scheme primitives.
#26
Environments
global environment + : #<primitive:+> null? : #<primitive:null?> x:3
Evaluation Rule 2: Names
A name expression evaluates to the value associated with that name.
To find the value associated with a name, look for the name in the frame associated with the evaluation environment. If it contains a place with that name, the value of the name expression is the value in that place. If it doesn't, the value of the name expression is the value of the name expression evaluated in the parent environment if the current environment has a parent. Otherwise, the name expression evaluates to an error (the name is not defined).
The global environment points to the outermost frame. It starts with all Scheme primitives.
> (define x 3) >
#27
#28
Procedures
global environment + : #<primitive:+> null? : #<primitive:null?> x:3 double: ???
How to Draw a Procedure
A procedure needs both code and an environment
We'll see why soon
We draw procedures like this:
Environment pointer environment: parameters: x body: (+ x x)
#29 #30
> (define x 3) > (define double (lambda (x) (+ x x))) >
How to Draw a Procedure (for artists only)
Environment pointer
global environment
Procedures
+ : #<primitive:+> null? : #<primitive:null?> x:3 double:
x
Input parameters (in mouth)
(+ x x)
Procedure Body
> (define double
(lambda (x) (+ x x)))
#31
environment: parameters: x body: (+ x x)
#32
Application
Old rule: (Substitution model) Apply Rule 2: Constructed Procedures. To apply a constructed procedure, evaluate the body of the procedure with each formal parameter replaced by the corresponding actual argument expression value.
New Application Rule 2:
1. Construct a new environment, whose parent is the environment to which the environment pointer of the applied procedure points. 2. Create places in that frame for each parameter containing the value of the corresponding operand expression. 3. Evaluate the body in the new environment. Result is the value of the application.
#33 #34
1.
2.
3.
global Construct a new environment environment, parent is procedure's environment + : #<primitive:+> pointer Make places in that x:3 double: frame with the names of each parameter, and operand values environment: Evaluate the body in the parameters: x new environment body: (+ x x) x :4
1.
2.
3.
Construct a new environment, parent is procedure's environment pointer Make places in that frame with the names of each parameter, and operand values Evaluate the body in the new environment
global environment + : #<primitive:+> x : 999
> (define x 999)
> (double 4)
8
(+ x x)
#35 #36
1.
2.
3.
Construct a new environment, parent is procedure's environment pointer Make places in that frame with the names of each parameter, and operand values Evaluate the body in the new environment
global environment + : #<primitive:+> x : 999 adder:
1.
2.
environment: parameters: body: x (lambda (y) (+ x y))
3.
Construct a new environment, parent is procedure's environment pointer Make places in that frame with the names of each parameter, and operand values Evaluate the body in the new environment
global environment + : #<primitive:+> x : 999 adder:
environment: parameters: x body: (lambda (y) (+ x y))
x:2
> (define x 999) > (define (adder x) (lambda (y) (+ x y))))
> (define x 999) > (define (adder x) (lambda (y) (+ x y)))) > (define addtwo (adder 2))
#37
#38
1.
2.
3.
Construct a new environment, parent is procedure's environment pointer Make places in that frame with the names of each parameter, and operand values Evaluate the body in the new environment
global environment + : #<primitive:+> x : 999 adder:
1.
2.
environment: parameters: x body: (lambda (y) (+ x y))
x:2
3.
Construct a new environment, parent is procedure's environment pointer Make places in that frame with the names of each parameter, and operand values Evaluate the body in the new environment
global environment + : #<primitive:+> :addtwo x : 999 adder:
environment: parameters: x body: (lambda (y) (+ x y))
x:2
> (define x 999) > (define (adder x) (lambda (y) (+ x y)))) > (define addtwo (adder 2))
environment: parameters: y body: (+ x y)
#39
> (define x 999) > (define (adder x) (lambda (y) (+ x y)))) > (define addtwo (adder 2))
environment: parameters: y body: (+ x y)
#40
1.
2.
3.
Construct a new environment, parent is procedure's environment pointer Make places in that frame with the names of each parameter, and operand values Evaluate the body in the new environment
global environment + : #<primitive:+> :addtwo x : 999 adder:
1.
2.
environment: parameters: x body: (lambda (y) (+ x y))
x:2
3.
Construct a new environment, parent is procedure's environment pointer Make places in that frame with the names of each parameter, and operand values Evaluate the body in the new environment
global environment + : #<primitive:+> :addtwo x : 999 adder:
environment: parameters: x body: (lambda (y) (+ x y))
x:2
> (define x 999) > (define (adder x) (lambda (y) (+ x y)))) > (define addtwo (adder 2)) > (addtwo 6)
environment: parameters: y body: (+ x y)
y:6
#41
> (define x 999) > (define (adder x) (lambda (y) (+ x y)))) > (define addtwo (adder 2)) > (addtwo 6) 8
environment: parameters: y body: (+ x y)
y:6
#42
Liberal Arts Trivia: Statistics
In probability theory and statistics, this indicates the strength and direction of a linear relationship between two random variables. A number of different coefficients are in different situations, the best known of which is the Pearson product-moment coefficient. Notably, this concept does not imply causation.
#43
Liberal Arts Trivia: Music
This baroque keyboard instrument is the spiritual predecessor of the pianoforte. It produces a sound by plucking a string when each key is pressed, but unlike the piano it lacks responsiveness to keyboard touch and thus fails to produce notes at different dynamic levels.
Jan Vermeer, 1670
#44
Science's Endless Golden Age
Astrophysics
"If you're going to use your computer to simulate some phenomenon in the universe, then it only becomes interesting if you change the scale of that phenomenon by at least a factor of 10. ... For a 3D simulation, an increase by a factor of 10 in each of the three dimensions increases your volume by a factor of 1000." How much work is astrophysics simulation (in notation)?
#46
http://www.pbs.org/wgbh/nova/sciencenow/3313/nn-video-toda-w-220.html
45
Astrophysics
"If you're going to use your computer to simulate some phenomenon in the universe, then it only becomes interesting if you change the scale of that phenomenon by at least a factor of 10. ... For a 3D simulation, an increase by a factor of 10 in each of the three dimensions increases your volume by a factor of 1000." How much work is astrophysics simulation (in notation)? When we double the size of the
140 120 100 80 60 40 20 0 1
Orders of Growth
n3
simulating universe
n2 n
insert-sort
(n3)
simulation, the work octuples! (Just like oceanography octopi simulations)
find-best
2 3 4 5
#47
#48
Orders of Growth
1400000 1200000 1000000 800000 600000 400000 200000 0 1 11 21 31 41 51 61 71 81 91 101
Astrophysics and Moore's Law
simulating universe
insert-sort find-best
Simulating universe is (n3) Moore's law: computing power doubles every 18 months Dr. Tyson: to understand something new about the universe, need to scale by 10x How long does it take to know twice as much about the universe?
#49 #50
Knowledge of the Universe
;;; doubling every 18 months = ~1.587 * every 12 months (define (computing-power nyears) (if (= nyears 0) 1 (* 1.587 (computing-power (- nyears 1))))) ;;; Simulation is (n3) work (define (simulation-work scale) (* scale scale scale)) (define (log10 x) (/ (log x) (log 10))) ;;; log is base e
;;; knowledge of the universe is log10 the scale of universe ;;; we can simulate
(define (computing-power nyears) (if (= nyears 0) 1 (* 1.587 (computing-power (- nyears 1))))) ;;; doubling every 18 months = ~1.587 * every 12 months (define (simulation-work scale) (* scale scale scale)) ;;; Simulation is O(n^3) work (define (log10 x) (/ (log x) (log 10))) ;;; primitive log is natural (base e) (define (knowledge-of-universe scale) (log10 scale)) ;;; knowledge of the universe is log 10 the scale of universe we can simulate
Knowledge of the Universe
...