5.4 the explicit-control evaluator

5/4/jord/lecture.org

@@ -0,0 +1,74 @@
+* Lecture 9B: Explicit-Control Evaluator
+https://youtu.be/Z8-qWEEwTCk
+text § 5.4
+
+whoa lookit that hat!!
+
+we've looked at the magic of building new languages
+
+: /                                \
+: |  escher     digital      query |
+: |   pict       logic             |
+: \                                /
+:            L   I   S   P
+
+q: "what is lisp good for?"
+a: "nothing in particular."
+
+lisp is good at constructing the right language for the 
+problem at hand
+
+so what's lisp based on?
+  the metacircular evaluator
+
+well what does that mean?
+
+"for our final piece of magic, we're going to make all the 
+magic go away"
+
+( woooOOOOoooOOOOooOOOO  :)
+
+we can build it on the register machine
+
+we already have all the ingredients
+
+i <3 the happy lisp user
+
+the machine has seven registers:
+  - exp
+  - env
+  - fun
+  - argl
+  - continue
+  - val
+  - unev
+
+the evaluator does a case analysis on the types of expressions
+
+THE EVAL/APPLY CYCLE
+
+--> break
+
+this is the first time ive seen a prepped blackboard
+
+LMAOOOO the execution unit!!! im dyingggg
+
+this is hella cool
+
+shouts out to our primitive operator!! slay queen!!
+
+--> break
+
+THE EVAL/APPLY CYCLE
+
+no accumulated state--when an expression is reduced, there is nothing
+  on the stack even though it might be in the middle of a function
+
+--> break
+
+look at a recursive procedure (in execution! not just definition)
+
+tail recursion comes from apply being very careful about what it needs
+next time
+
+ok let's stop!

5/4/jord/notes.org

@@ -0,0 +1,71 @@
+* The Explicit-Control Evaluator
+this is how to implement /scheme itself/ on bare metal. cool as hell.
+
+the register machine contains a stack and seven registers:
+  - exp
+  - env
+  - val
+  - continue
+  - proc
+  - argl
+  - unev
+
+** 5.4.1 the core of the explicit-control evaluator
+the central element of the evaluator is the sequence of instructions
+beginning at eval-dispatch
+
+after eval, the controller goes the the entry point stored in continue
+and the val register holds the value of the expression
+
+eval-dispatch is a case analysis on the syntactic type of expression
+to be evaluated
+
+** 5.4.2 sequence evaluation and tail recursion
+this handles sequences of expressions in procedure bodies or in begin
+expressions. 
+
+TAIL RECURSION
+a procedure such as
+#+BEGIN_SRC scheme
+  (define (sqrt-iter guess x)
+    (if (good-enuff? guess x)
+	guess
+	(sqrt-iter (improve guess x)
+		   x)))
+#+END_SRC
+is syntactically recursive but operationally iterative. but only with
+tail recursion.
+
+  - tail-recursive evaluator :: an evaluator that can execute a
+       procedure such as sqrt-iter without requiring increasing
+       storage as the procedure continues to call itself
+
+implementing tail recursion is a simple, universal, and profound thing
+
+** 5.4.3 conditionals, assignment, and definitions
+special forms are handles by selectively evaluating fragments of the
+expression. assignments and definitions are handled similarly with
+set-variable-value!
+
+** 5.4.4 running the evaluator
+with the implementation of the evaluator we have come to the
+conclusion of a development started back in chapter 1, exploring more
+precise models of evaluation:
+  - substitution
+    - relatively informal
+  - environment
+    - deal with state and change
+  - metacircular evaluator
+    - using scheme itself
+  - register machines
+    - a close look at the mechanisms for storage management, argument
+      passing, and control
+each layer raised issues and ambiguities that were not apparent at the
+previous levels.
+
+now we can implement and monitor the performance of our machine at its
+basest levels.
+
+the simulation will of course be slow (it's a simulation running in a
+simulation running in a simulation...) but we can do cool things like
+monitor and evaluate its performance.