Carlos Varela RPI Adapted with permission from: Seif Haridi KTH Peter Van Roy UCL

1. Declarative Computation ModelMemory management, Exceptions, From kernel to practical language (2.5-2.7) Carlos Varela RPI Adapted with permission from: Seif Haridi KTH Peter Van Roy UCL C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

2. From the kernel languageto a practical language • Interactive interface • the declare statement and the global environment • Extend kernel syntax to give a full, practical syntax • nesting of partial values • implicit variable initialization • expressions • nesting the ifand case statements • andthen and orelse operations • Linguistic abstraction • functions C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

3. The interactive interface (declare) • The interactive interface is a program that has a single global environment declare X Y • Augments (and overrides) the environment with new mappings for X and Y {Browse X} • Inspects the store and shows partial values, and incremental changes C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

4. The interactive interface (declare) procedurevalue Store Browse F value X Y a b Environment C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

5. declareXY procedurevalue Store Browse F value X a Y b Environment xi unbound unbound xi+1 C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

6. Syntactic extensions • Nested partial values • person(name: “George” age:25) local A B in A= “George” B=25 person(name:A age:B) end • Implicit variable initialization • localpattern = expressionin statementend • Example:assume T has been defined, then local tree(key:A left:B right:C value:D) = T instatementend is the same as: local A B C D in T = tree(key:A left:B right:C value:D) <statement>end C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

7. Extracting fields in local statement declare T : T = tree(key:seif age:48 profession:professor) : local tree(key:A ...) = T in statement end C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

8. Nested if and case statements • Observe a pair notation is: 1 # 2, is the tuple ‘#’(1 2) case Xs # Ysof nil # Ys thens1 [] Xs # nil then s2[] (X|Xr) # (Y|Yr) andthen X=<Y then s3 else s4 end • Is translated intocase Xs of nil thens1elsecase Ys of nil then s2elsecase Xs of X|Xr thencase Ys of Y|Yr thenif X=<Y then s3 else s4endelse s4endelse s4endendend C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

9. Expressions • An expression is a sequence of operations that returns a value • A statement is a sequence of operations that does not return a value. Its effect is on the store, or outside of the system (e.g. read/write a file) • 11*11 X=11*11 expression statement C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

10. Functions as linguistic abstraction • {F X1 ... Xn R} • R = {F X1 ... Xn} proc {F X1 ... Xn R}statementR = expression end fun {F X1 ... Xn}statementexpression end statement statement C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

11. Nesting in data structures • Ys = {F X}|{Map Yr F} • Is unnested to: • local Y Yr in Ys = Y|Yr {F X Y} {Map Xr F Yr}end • The unnesting of the calls occurs after the data structure C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

12. Functional nesting • Nested notations that allows expressions as well as statements • local R in {F X1 ... Xn R} {Q R ...}end • Is written as (equivalent to): • {Q {F X1 ... Xn} ...} expression statement C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

13. Conditional expressions R = ifexpr1then expr2else expr3end ifexpr1thenR = expr2 else R = expr3end expression statement fun{Max X Y} if X>=Y then X else Y end end proc{Max X Y R} R =( if X>=Y then X else Y end ) end C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

14. Example fun{Max X Y} if X>=Y then X else Y end end proc{Max X Y R} R =( if X>=Y then X else Y end ) end proc{Max X Y R} if X>=Y then R = X else R = Y end end C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

15. andthen and orelse if expr1 thenexpr2 else false end expr1 andthen expr2 if expr1 thentrue else expr2end expr1 orelse expr2 C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

16. Function calls Observe local R1 R2inR1 = {F2 X}R2 = {F3 Y}{F1 R1 R2} end {F1 {F2 X} {F3 Y}} The arguments of a function are evaluatedfirst from left to right C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

17. A complete example fun {Map Xs F}case Xsof nil then nil[] X|Xr then {F X}|{Map Xr F}end end proc {Map Xs F Ys}case Xsof nil then Ys = nil[] X|Xr then Y Yr in Ys = Y|Yr {F X Y} {Map Xr F Yr}end end C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

18. Back to semantics • Efficient loops in the declarative model • recursion used for looping • is efficient because of last call optimization • memory management and garbage collection • Exceptions • Functional programming C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

19. Last call optimization • Consider the following procedureproc {Loop10 I}if I ==10 then skipelse {Browse I} {Loop10 I+1}endend • This procedure does not increase the size of the STACK • It behaves like a looping construct C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

20. Last call optimization proc {Loop10 I}if I ==10 then skipelse {Browse I} {Loop10 I+1}endend ST: [ ({Loop10 0}, E0) ] ST: [({Browse I}, {Ii0,...}) ({Loop10 I+1}, {Ii0,...}) ] : {i0=0, ...} ST: [({Loop10 I+1}, {Ii0,...}) ] : {i0=0, ...} ST: [({Browse I}, {Ii1,...}) ({Loop10 I+1}, {Ii1,...}) ] : {i0=0, i1=1,...} C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

21. Garbage collection proc {Loop10 I}if I ==10 then skipelse {Browse I} {Loop10 I+1}endend ST: [({Browse I}, {Iik,...}) ({Loop10 I+1}, {Iik,...}) ] : {i0=0, i1=1,..., ik-i=k-1, ik=k,... } Garbage collection is an algorithm (a task) that removes from memory (store) all cells that are not accessible from the stack ST: [({Browse I}, {Iik,...}) ({Loop10 I+1}, {Iik,...}) ] : {ik=k, ... } C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

22. The memory use cycle • Active memory is what the program needs to continue execution (semantic stack + reachable part of store) • Memory that is no longer needed is of two kinds: • Can be immediately deallocated (i.e., semantic stack) • Simply becomes inactive (i.e., store) • Reclaiming inactive memory is the hardest part of memory management • Garbage collection is automatic reclaiming Allocate/ deallocate Active Free Become inactive (program execution) Reclaim (garbage collection) Inactive C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

23. The Mozart Garbage Collector • Copying dual-space algorithm • Advantage : Execution time is proportional to the active memory size • Disadvantage : Half of the total memory is unusable at any given time C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

24. Exceptions • How to handle exceptional situations in the program? • Examples: • divide by 0 • opening a nonexistent file • Some errors are programming errors • Some errors are imposed by the external environment • Exception handling statements allow programs to handle and recover from errors C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

25. Exceptions • Exception handling statements allow programs to handle and recover from errors • The error confinement principle: • Define your program as a structured layers of components • Errors are visible only internally and a recovery procedure corrects the errors: either errors are not visible at the component boundary or are reported (nicely) to a higher level • In one operation, exit from arbitrary depth of nested contexts • Essential for program structuring; else programs get complicated (use boolean variables everywhere, etc.) C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

26. Basic concepts • A program that encounters an error (exception) should transfer execution to another part, the exception handler and give it a (partial) value that describes the error • trys1catch xthen s2 end • raise xend • Introduce an exception marker on the semantic stack • The execution is equivalent to s1 if it executes without raising an error • Otherwise, s1is aborted and the stack is popped up to the marker, the error value is transferred through x, and s2is executed C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

27. Exceptions (Example) fun {Eval E} if {IsNumber E} then Eelsecase Eof plus(X Y) then {Eval X}+{Eval Y}[] times(X Y) then {Eval X}*{Eval Y}elseraise illFormedExpression(E) endendend end plus times 5 6 4 C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

28. Exceptions (Example) try{Browse {Eval plus(5 6) }}{Browse {Eval plus(times(5 5) 6) }}{Browse {Eval plus(minus(5 5) 6) }} catch illFormedExpression(E) then{System.showInfo ”**** illegal expresion ****” # E} end C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

29. Try semantics • The semantic statement is (try s1catch y then s2end, E) • Push the semantic statement (catch y then s2end, E) on ST • Push (s1, E) on ST • Continue to next execution step C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

30. Raise semantics • The semantic statement is (raise x end, E) • Pop elements off ST looking for a catch statement: • If a catch statement is found, pop it from the stack • If the stack is emptied and no catch is found, then stop execution with the error message ”Uncaught exception” • Let (catch y then s end, Ec) be the catch statement that is found • Push (s , Ec+{<y>E(<x>)}) on ST • Continue to next execution step C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

31. Catch semantics • The semantic statement is (catch x then s end, E) • Continue to next execution step (like skip) C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

32. Full exception syntax • Exception statements (expressions) with multiple patterns and finally clause • Example::FH = {OpenFile ”xxxxx”}:try {ProcessFile FH}catch X then {System.showInfo ”***** Exception when processing *****” # X}finally {CloseFile FH} end C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

33. Strictly functional • Restrict the language to make the language functional (I.e.without dataflow variables) • Language similar to Scheme (dynamically typed functional language) • This is done by disallowing variable declaration (without initialization) and disallowing procedural syntax • Only use implicit variable initialization • Only use functions C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

34. Exercises • What do you expect to happen if you try to execute the following statement? Try to answer without actually executing it! local T = tree(key:A left:B right:C value:D) in A = 1 B = 2 C = 3 D = 4 end C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

35. Exercise • Here is a construct that uses some syntactic sugar : local T in local tree(left:A right:B) = T in <stmt> end Here is an attempt to write the same construct using kernel language syntax and assuming there is an AssignLabel operation in Oz : local T in local A B in {AssignLabel T tree} T.right = B T.left = A <stmt> end end Are the above constructs always equivalent? Can you find a case when they are not? If not, how will you justify your belief that they are equivalent? C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

36. Exercise • Suppose that A and B are predefined variables and Func1 is a predefined one argument function. Here is a construct that uses some syntactic sugar: local T in tree(left:{Func1 A} right:{Func1 B}) = T end Here is an attempt to write the same construct using the kernel language and assuming there is an AssignLabel procedure in Oz: local T in {AssignLabel T tree} T.right = {Func1 B} T.left = {Func1 A} end • Are the above constructs always equivalent? Note that they may suspend or abort at a different places in which case they are not considered to be equivalent. • How will your answer change if you are told that neither A nor B is unbound? • How will your answer change if you are told that neither A nor B is unbound, and Func1 never throws an exception? • How will your answer change if you are told that neither A nor B is unbound, and Func1 is a lambda combinator? • How will your answer change if you are told that neither A nor B is unbound, and Func1 never throws an exception, and Func1 is a lambda combinator? C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

37. Exercise • The C++ language has a facility to declare static variables in a function. Read about them if you don’t know what they are. Now, conceptually describe – How can you add a similar facility to Oz? Will you add it as an extension of the kernel language or as a linguistic abstraction? (You need not follow the same syntax as C++. Your semantics should be approximately the same) • Any realistic computer system has a memory cache for fast access to frequently used data. Read about caches if you don’t know what they are. Can you think of any issues with garbage collection in a system that has a memory cache? C. Varela; Adapted w/permission from S. Haridi and P. Van Roy

38. Exercise • Do problems 3, 9 and 12 in Section 2.9 • Read Sections 3.7 and 6.4 C. Varela; Adapted w/permission from S. Haridi and P. Van Roy