3.1 assignment and local state

3/1/jord/exercises.org

@@ -0,0 +1,56 @@
+CHAPTER 3
+* Exercise 3.1
+#+BEGIN_SRC scheme
+  (define (make-accumulator start)
+    (lambda (add) (begin (set! start (+ start add))
+			 start)))
+  (define A (make-accumulator 3))
+  (A 10)
+#+END_SRC
+* Exercise 3.2
+#+BEGIN_SRC scheme
+  (define (sqrt x) (* x x))
+  (define (make-monitored f)
+    (let ((calls 0))
+      (define (mf input)
+	(cond ((eq? input 'how-many-calls?)
+	       calls)
+	      ((eq? input 'reset-count)
+	       (begin (set! calls 0)
+		      calls))
+	      (else (begin (set! calls (+ 1 calls))
+			   (f input)))))
+      mf))
+  (define ctsqrt (make-monitored sqrt))
+  (ctsqrt 100)
+  (ctsqrt 1000)
+  (ctsqrt 10000)
+  (ctsqrt 'how-many-calls?)
+#+END_SRC
+* Exercise 3.3
+#+BEGIN_SRC scheme
+  (define (make-account balance password)
+    (let ((pw password))
+      (define (withdraw amount)
+	(if (>= balance amount)
+	    (begin (set! balance (- balance amount))
+		   balance)
+	    "Insufficient Funds"))
+      (define (deposit amount)
+	(set! balance (+ balance amount))
+	balance)
+      (define (dispatch m password)
+	(cond ((not (eq? password pw))
+	       (error "wrong password"))
+	      ((eq? m 'withdraw) withdraw)
+	      ((eq? m 'deposit) deposit)
+	      (else (error "Unknown request -- MAKE-ACCOUNT"
+			   m))))
+      dispatch))
+
+  (define acc (make-account 100 'opensesame))
+  ((acc 'deposit 'opensesame) 20)
+
+  ;;(define (make-joint acct password new-pass)
+
+#+END_SRC

3/1/jord/lecture.org

@@ -0,0 +1,197 @@
+* Lecture 5A: Assignment, State, and Side-Effects
+https://youtu.be/dO1aqPBJCPg
+text § 3.1 & 3.2
+
+"so far we've invented enough programming to do some very complicated
+things."
+
+so far we have worked without assignment, "in pascal a very basic
+thing."
+
+so now we are going to do a "horrible" thing: introduce assignment
+
+the reason is to give the power of another means of decomposition
+
+so far we have been writing funtional programs
+
+these programs can be understood by substitution
+
+:			time axis
+:			    |
+:	<before>	    |
+:			    |
+: (set! <var> <val>) -------+------------
+:			    |
+:	<after>		    |  <var> has value
+:			    |  <val>
+:			    |
+:			    v
+
+
+: (define count 1)
+: (define (demo x)
+:   (set! count (1+ count))
+:   (+ x count))
+: => (demo 3)
+: 5
+: => (demo 3)
+: 6
+
+demo is not a function. it leads to multiple values, based on TIME
+
+substitution is static -- it describes things that are true, not
+  things that change
+
+"this is a very bad thing!! going to cause a lot of trouble!!"
+but there's a good reason
+
+FUNCTIONAL VERSION (substitution works):
+#+BEGIN_SRC scheme
+  (define (fact n)
+    (define (iter m i)
+      (cond ((> i n) m)
+	    (else (iter (* i m) (+ i 1)))))
+    (iter 1 1))
+#+END_SRC
+
+IMPERATIVE VERSION (substitution eats shit):
+#+BEGIN_SRC scheme
+  (define (fact-i n)
+    (let ((i 1) (m 1))
+      (define (loop)
+	(cond ((> i n) m)
+	      (else
+	       (set! m (* i m)) ;; a subtle bug
+	       (set! i (+ i 1)) ;; can live here
+	       (loop))))
+      (loop)))
+#+END_SRC
+
+--> break
+
+we have to transition to the *environment model*
+
+there is a bunch of important and unfortunate terminology
+
+  - bound variables :: var v is bound in an exp e if the meaning of e
+       is unchanged by the uniform replacement of var w (not in e) for
+       every occurance of v in e
+
+λ is the essential variable binder
+
+: (λ (y) ((λ (x) (* x y)) 3))
+
+there are two bound vars: x and y
+  if replaced all the y's with w's, it's the same procedure
+
+: (λ (x) (* x y))
+
+y is not bound.
+
+  - free variable :: var v is free in an exp e if the meaning of e is
+                     changed by the uniform replacement of a var w
+                     (not in e) for every occurance of v in e
+
+  - scope :: the lambda bind the vars in it's arg list to a scope
+
+environments are ways of doing substitution virtually
+
+envs are made out of frames, chained together, by parent links
+
+procedures are made out of two parts
+  - some code
+  - an environment
+
+a var in the procedure is either bound or free.
+
+RULE 1: a procedure is applied to its args by building a frame,
+  binding formal params to the actual args of the call, then
+  evaluating the body of the procedure in the context of the new
+  env. the new frame has as its enclosing env the env part of the
+  procedure obj being applied
+
+RULE 2: a λ exp is evaluated relative to an env by forming a new
+  procedure obj, combining the text (code) of the λ exp with a pointer
+  to the env of evaluation
+
+--> break
+
+now,,, WHY would gjs have done this cruel thing to us?
+
+#+BEGIN_SRC scheme
+  (define make-counter
+    (lambda (n)
+      (lambda ()
+	(set! n (1+ n))
+	n)))
+#+END_SRC
+
+we have to make an env for this procedure
+
+:    | +  *  /  -			     GLOBAL
+:    | cons  car
+:    |		       make-counter
+:    |       C1                         C2
+:    +----------------------------------------------
+:             ^       ^                  ^       ^
+:         env |       |              env |       |
+:             |       |                  |       |
+: proc (00)---+  --  |n=0|   proc (00)---+  --  |n=10|
+:       |                          |
+:    (λ ...)                    (λ ...)
+
+#+BEGIN_SRC scheme
+  (define C1 (make-counter 0))
+  (define C2 (make-counter 10))
+#+END_SRC
+
+
+ACTION AND IDENTITY
+  we say that an action a had an effect on an obj x if some property p
+  which was true of x before a became false of x after a
+
+  we say that two objs, x and y, are the same if any action which has
+  an effect on x has the same effect on y
+
+A FUN GAME:
+#+BEGIN_SRC scheme
+  ;;; cesaro's method for estimating π:
+  ;;;   Prob(gcd(n1,n2)=1) = 6/(pi*pi)
+
+  (define (estimate-pi n)
+    (sqrt (/ 6 (monte-carlo n cesaro))))
+  (define (cesaro)
+    (= (gcd (rand) (rand)) 1))
+#+END_SRC
+
+#+BEGIN_SRC scheme
+  ;;; the monte-carlo technique
+
+  (define (monte-carlo trials experiment)
+    (define (iter remaining passed)
+      (cond ((= remaining 0)
+	     (/ passed trials))
+	    ((experiment)
+	     (iter (-1+ remaining)
+		   (1+ passed)))
+	    (else
+	     (iter (-1+ remaining)
+		   passed))))
+    (iter trials 0))
+#+END_SRC
+
+#+BEGIN_SRC scheme
+  ;;; the random number generator
+  ;;;   containing hidden local state
+
+  (define rand
+    (let ((x random-init))
+      (lamda ()
+	     (set! x (rand-update x))
+	     x)))
+#+END_SRC
+
+gjs name-checks donald knuth!
+
+"things are seldom what they seem, skim milk masquerades as cream..."
+  - gilbert & sullivan (hms pinafore)

3/1/jord/notes.org

@@ -0,0 +1,175 @@
+Chapter 3: Modularity, Objects, and State
+
+so far we have reviewed the primitive elements of how programs are
+made and how those primitive elements can be combined in complex
+ways.
+
+we learned the value of abstraction and modular programs.
+
+  - modular :: the nature of a program thot it can be divided
+               "naturally" into coherent parts that can be separately
+               developed and maintained
+
+we now look towards how to design entire systems. we will look at two
+prominent strategies for program construction:
+  - objects :: seeing a program as a collection of distinct objects
+               whose behaviors may change over time
+  - streams :: seeing a program as a flow of information in a system
+
+we will finally discard the substitution model of chapter 1 in favor
+of the environment model
+
+* 3.1 assignment and local state
+we ordinarily view the world as a collection of independent objects
+each of which has state that changes over time.
+
+at this point (in ch 3!!!) we will discuss local state variables and
+the assignment operator
+
+** 3.1.1 local state variables
+we now have a comptational object with time-varying state
+
+this means:
+: (withdraw 25) --> 75
+: (withdraw 25) --> 25
+: (withdraw 60) --> "Insufficient Funds"
+: (withdraw 15) --> 35
+
+these are not pure funtions
+
+when evaluated twice, they yield different results
+
+this is /new/ before, we computed mathematical functions
+
+#+BEGIN_SRC scheme
+  (define balance 100)
+
+  (define (withdraw amount)
+    (if (>= balance amount)
+	(begin (set! balance (- balance amount))
+	       balance)
+	"Insufficient Funds"))
+#+END_SRC
+
+we have the new language features, set! which sets a new value to a
+variable: 
+: (set! name new-value)
+
+and we have the (begin ... ... ...) form, which returns the value of
+its final expression
+
+there's some trouble with that begin variable. we can make it
+internal by encapsulating it:
+#+BEGIN_SRC scheme
+  (define new-withdraw
+    (let ((balance 100))
+      (lambda (amount)
+	(if (>= balance amount)
+	    (begin (set! balance (- balance amount))
+		   balance)
+	    "Insufficient Funds"))))
+#+END_SRC
+
+combining set! with local variables is the general technique for
+constructing computational objects.
+
+--> here we have just annhialated our substitution model. according to
+    it, the above is incomprehensible. we will address later. first, a
+    few variations on this new and very exciting theme
+
+#+BEGIN_SRC scheme :session mw
+  (define (make-withdraw balance)
+    (lambda (amount)
+      (if (>= balance amount)
+	  (begin (set! balance (- balance amount))
+		 balance)
+	  "Insufficient Funds")))
+#+END_SRC
+
+#+RESULTS:
+: make-withdraw
+
+which can be used to make accounts with custom amounts
+
+#+BEGIN_SRC scheme :session mw
+  (define W1 (make-withdraw 100))
+  (define W2 (make-withdraw 100))
+  (W1 50)
+  (W2 70)
+#+END_SRC
+
+#+RESULTS:
+: 30
+
+these two withdrawal accounts are independent of each other
+
+to make a functional bank account:
+#+BEGIN_SRC scheme :session bank
+  (define (make-account balance)
+    (define (withdraw amount)
+      (if (>= balance amount)
+	  (begin (set! balance (- balance amount))
+		 balance)
+	  "Insufficient Funds"))
+    (define (deposit amount)
+      (set! balance (+ balance amount))
+      balance)
+    (define (dispatch m)
+      (cond ((eq? m 'withdraw) withdraw)
+	    ((eq? m 'deposit) deposit)
+	    (else (error "Unknown request -- MAKE-ACCOUNT"
+			 m))))
+    dispatch)
+#+END_SRC
+
+#+RESULTS:
+: make-account
+
+and to use it:
+#+BEGIN_SRC scheme :session bank
+  (define acc (make-account 100))
+  ((acc 'withdraw) 25)
+  ((acc 'withdraw) 80)
+  ((acc 'deposit) 120)
+  ((acc 'withdraw) 60)
+#+END_SRC
+
+#+RESULTS:
+: 135
+
+and:
+#+BEGIN_SRC scheme :session bank
+  (define acc2 (make-account 100))
+#+END_SRC
+
+#+RESULTS:
+: acc2
+
+will be a completely different account
+
+** 3.1.2 the benefits of introducing assignment
+
+with assignment, we can encapsulate state, rather than injecting it
+via formal parameters all over the place.
+
+** 3.1.3 the costs of introducing assignment
+
+set! is cool, but it breaks the substitution model.
+
+it breaks all "nice" mathematical models.
+
+the reason it doesnt work is variable scope. like closures, i
+think. or like the kind of closure this book said is the wrong thing.
+
+
+  - functional programming :: as we did in the first two chapters of
+       the book, to not use assignment
+  - imperative programming :: makes extensive use of assignment
+
+SAMENESS AND CHANGE
+
+  - referentially transparent :: "equals can be substituted for
+       equals" without changing the value of an expression
+
+set! violates referential transparency.
+