1 structure and interpretation of computer programs modularity, objects, and state (part 1) abelson...
TRANSCRIPT
![Page 1: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/1.jpg)
1
Structure and Interpretation of Computer
ProgramsModularity, Objects, and State (part 1)
Abelson & Sussman2
UC San DiegoCSE 294
May 11, 2011Barry Demchak
![Page 2: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/2.jpg)
2
Agenda
Functional vs Imperative languages OOP in Functional languages (e.g., Clojure) Data Encapsulation case studies
Simple mutability (persistence) A simple object
Mutability support Failings of the substitution model The environment model Method dispatch
Language comparisons
![Page 3: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/3.jpg)
3
Functional vs Imperative (1/2)
Programming without any use of assignments … is … known as functional programming.p230
Looping via recursion Higher order programming Repeatable function execution memoization Fewer special forms
Programming that makes extensive use of assignment is … imperative programming.p234
Explicit control structures and special forms Introduces significant data dependency
![Page 4: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/4.jpg)
4
Functional vs Imperative (2/2)
Java/C++/Pascalint factAnswer = 1;for (int counter = 2; counter <= n; counter++)
factAnswer = factAnswer * counter;
Maps directly to registers and compare/jump Lisp/Clojure
(defn factorial [n](if (<= n 1)
1(* n (factorial (dec n)))))
Maps to recurrence relation
![Page 5: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/5.jpg)
5
Agenda
Functional vs Imperative languages OOP in Functional languages (e.g., Clojure) Data Encapsulation case studies
Simple mutability (persistence) A simple object
Mutability support Failings of the substitution model The environment model Method dispatch
Language comparisons
![Page 6: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/6.jpg)
6
Object Oriented Programming
Major properties Abstraction Inheritance Polymorphism Data encapsulation
Major uses Manage complexity Multiple instances of stateful entities Orchestration of stateful entities
Key point: Stateful entities change over time
![Page 7: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/7.jpg)
7
Functional Programming vs OOP
Contradiction Repeatable execution requires immutability
Substitution model(defn factorial [n]
(if (<= n 1)1(* n (factorial (dec n)))))
(factorial 3) (* 3 (factorial 2)) (* 3 (* 2 (factorial 1))) (* 3 (* 2 (* 1 1)))
OOP depends on mutability
![Page 8: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/8.jpg)
8
Agenda
Functional vs Imperative languages OOP in Functional languages (e.g., Clojure) Data Encapsulation case studies
Simple mutability (persistence) A simple object
Mutability support Failings of the substitution model The environment model Method dispatch
Language comparisons
![Page 9: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/9.jpg)
9
Bringing OOP to Functional
Abstraction (as seen by Valentin) Inheritance Polymorphism Data Encapsulation …implies mutable state
Suppose a min() function(defn min [x y]
(if (<= x y) x y))where (min 5 6) -> 5
(min 5 6) -> 5 …
Define last-min() to return last min() calculated
![Page 10: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/10.jpg)
10
Simple Persistence
Global persistence
(def last-min (atom 0))
(defn min [x y] (reset! last-min (if (<= x y) x y)))
No encapsulation
Single instance only
(reset! <name> <value>)
(swap! <name> <func>)
![Page 11: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/11.jpg)
11
(defn min-obj [init-min]
(let [last-min (atom init-min)]
(defn do-min [x y]
(reset! last-min (if (<= x y) x y)))
(defn get-last [] (deref last-min))
{:get #(get-last)
:min #(do-min %1 %2)}))
A Min Object
http://thinkrelevance.com/blog/2009/08/12/rifle-oriented-programming-with-clojure-2.html
![Page 12: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/12.jpg)
12
A Min Object
(defn min-obj [init-min]
(let [last-min (atom init-min)]
(defn do-min [x y]
(reset! last-min (if (<= x y) x y)))
(defn get-last [] (deref last-min))
{:get #(get-last)
:min #(do-min %1 %2)}))
(define min1 (min-obj 1000000)) Constructor
![Page 13: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/13.jpg)
13
A Min Object
(defn min-obj [init-min]
(let [last-min (atom init-min)]
(defn do-min [x y]
(reset! last-min (if (<= x y) x y)))
(defn get-last [] (deref last-min))
{:get #(get-last)
:min #(do-min %1 %2)}))
(define min1 (min-obj 1000000))((min1 :min) 5 6) Call to min()
![Page 14: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/14.jpg)
14
A Min Object
(defn min-obj [init-min]
(let [last-min (atom init-min)]
(defn do-min [x y]
(reset! last-min (if (<= x y) x y)))
(defn get-last [] (deref last-min))
{:get #(get-last)
:min #(do-min %1 %2)}))
(define min1 (min-obj 1000000))((min1 :min) 5 6)((min1 :get)) Fetch last min
![Page 15: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/15.jpg)
15
Agenda
Functional vs Imperative languages OOP in Functional languages (e.g., Clojure) Data Encapsulation case studies
Simple mutability (persistence) A simple object
Mutability support Failings of the substitution model The environment model Method dispatch
Language comparisons
![Page 16: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/16.jpg)
16
(defn min-obj [init-min]
(let [last-min (atom init-min)]
(defn do-min [x y]
(reset! last-min (if (<= x y) x y)))
(defn get-last [] (deref last-min))
{:get #(get-last)
:min #(do-min %1 %2)}))
(define min1 (min-obj 1000000))((min1 :get))
The Problem: Binding last-min
![Page 17: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/17.jpg)
17
The Solution: Environments
Global environment
min:
other variables
parameters: x ybody: (if …)
(defn min [x y] (if (<= x y) x y))
What happens when you define min():
![Page 18: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/18.jpg)
18
The Solution: Environments
Global environment
min:
other variables
parameters: x ybody: (if …)
(defn min [x y] (if (<= x y) x y))
What happens when you define min():
![Page 19: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/19.jpg)
19
Simple Execution
What happens when you execute min():
Global environment
min:
other variables
parameters: x ybody: (if …)
(min 5 6)
E1 environmentx: 5y: 6
(if …)
![Page 20: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/20.jpg)
20
Simple Execution
What happens when you execute min():
Global environment
min:
other variables
parameters: x ybody: (if …)
(min 5 6)
E1 environmentx: 5y: 6
(if …)
Variable references resolved by traversing environment chain
![Page 21: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/21.jpg)
21
(defn min-obj [init-min]
(let [last-min (atom init-min)]
(defn do-min [x y]
(reset! last-min (if (<= x y) x y)))
(defn get-last [] (deref last-min))
{:get #(get-last)
:min #(do-min %1 %2)}))
(define min1 (min-obj 1000000))((min1 :get))
How Does min-obj Get Defined?
![Page 22: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/22.jpg)
22
Object Definition
Global environment
min-obj:
other variables
parameters: init-minbody: (let [... )
(defn min-obj [init-min] (let [...))
What happens when you define min-obj():
![Page 23: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/23.jpg)
23
Object Instantiation
How do you instantiate min-obj():
Global environment
min-obj:
other variables
parameters: init-minbody: (let [... )
(def min1 (min-obj 1000000))
min1:
parameters: body: (:get #(…), :min #(…))
last-min: 1000000do-min: get-last:
Environment E1
parameters: x ybody: (reset! …)
parameters: body: (deref …)
![Page 24: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/24.jpg)
24
Object Instantiation
How do you instantiate min-obj():
Global environment
min-obj:
other variables
parameters: init-minbody: (let [... )
(def min1 (min-obj 1000000))
min1:
parameters: body: (:get #(…), :min #(…))
last-min: 1000000do-min: get-last:
Environment E1
parameters: x ybody: (reset! …)
parameters: body: (deref …)
![Page 25: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/25.jpg)
25
Method Execution
How do you execute min():
Global environment
min-obj:
other variables
parameters: init-minbody: (let [...)
((min1 :min) 5 6)
min1:
parameters: body: (:get #(…), :min #(…))
last-min: 1000000do-min: get-last:
Environment E1
parameters: x ybody: (reset! …)
parameters: body: (deref ...)
E2x: 5y: 6
![Page 26: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/26.jpg)
26
Functional Language OOP
Data encapsulation as a result of Constructor parameter accessible only within
function Binding of internal functions to constructor
parameter allows state retention Other points
Dismantling of environments amenable to access count tracking
Dispatcher can operate on any criteria, and is pre-wired for SOA-style message passing
![Page 27: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/27.jpg)
27
Future Investigation
How to subclass How inheritance works Existing (or desirable) object frameworks Why isn’t OOP very common in Clojure?
![Page 28: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/28.jpg)
28
Agenda
Functional vs Imperative languages OOP in Functional languages (e.g., Clojure) Data Encapsulation case studies
Simple mutability (persistence) A simple object
Mutability support Failings of the substitution model The environment model Method dispatch
Language comparisons
![Page 29: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/29.jpg)
29
Selected Comparisons
Deep Static Scope
Data Encapsulation
Clojure/Lisp Arbitrary depth Yes
Pascal Arbitrary depth Yes, but no instances
Java/C++ No Yes
![Page 30: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/30.jpg)
30
Data Encapsulation Comparison
(defn min-obj [init-min] (let [last-min (atom init-min)] (defn do-min [x y] (reset! last-min (if (<= x y) x y))) (defn get-last [] (deref last-min)) {:get #(get-last) :min #(do-min %1 %2)}))
(define min1 (min-obj 1000000))((min1 :min) 5 6)((min1 :get))
class min_obj { private int last_min; public min_obj(int init_min) { last_min = init_min;} public int min(int x, int y) { last_min = (x <= y ? x : y); return last_min; } public int get () { return last_min;}}
min_obj a = new min_obj(1000000);a.min(5, 6);a.get();
Clojure Java
![Page 31: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/31.jpg)
31
Static Scoping in Pascal
program test;var a : integer; procedure outer(); var b : integer; procedure inner(); var c : integer; begin c := a + b; end; begin b := a; inner(); end;begin a := 0; outer(); end.
Evaluation Stack
a
prev-frame-ptr
b
prev-frame-ptr
c
prev-frame-ptr
Compiler knows stack location of all variables in scope – no traversing
![Page 32: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/32.jpg)
32
Agenda
Functional vs Imperative languages OOP in Functional languages (e.g., Clojure) Data Encapsulation case studies
Simple mutability (persistence) A simple object
Mutability support Failings of the substitution model The environment model Method dispatch
Language comparisons
![Page 33: 1 Structure and Interpretation of Computer Programs Modularity, Objects, and State (part 1) Abelson & Sussman 2 UC San Diego CSE 294 May 11, 2011 Barry](https://reader036.vdocuments.site/reader036/viewer/2022070409/56649e9e5503460f94b9f269/html5/thumbnails/33.jpg)
33
Questions