First-class Implementations

Transcription

1 First-class Implementations Turtling down Runtime Meta-levels and PCLSRing up François-René Rideau, TUNES Project BostonHaskell,

2 This Talk Salvaged from my aborted 1999 PhD thesis: The Semantics of Reflective Systems Cousot at ENS was teaching Abstract Interpretation. All I was interested in was the opposite direction: Concrete Implementation 2

3 The Take Home Points Implementation is co-(abstract Interpretation) Safe points are a key concept First-class: the opposite of magic First-class safe points (= PCLSRing!) Applications: Migration, Optimistic Evaluation, etc. Composing implementations for fun and profit Runtime meta-programming brings new modularity 3

4 Plan Implementation: Formalizing the notion First-class Implementation protocol Applications of First-class Implementations Runtime meta-programming architecture 4

5 I. Formalizing the notion of Implementation 5

6 Abstract Interpretation 6

7 Concrete Implementation 7

8 Concrete Implementation vs Abstract Interpretation Dynamic (Runtime) vs Static (Compile-time) Operational Semantics vs Denotational Semantics Downward (concrete) vs Upward (abstract) Co-functorial vs Functorial Noisy vs lossy Non-deterministic vs deterministic 8

9 Categories 9

10 Categories 10

11 Partial Functions (1) 11

12 Partial Functions (2) 12

13 Partial Functions (3) 13

14 Deduction 14

15 Observable State 15

16 Observable State o = c 16

17 Operational Semantics 17

18 Soundness 18

19 Totality 19

20 Completeness 20

21 Advance Preservation 21

22 Liveness 22

23 Strong Liveness 23

24 Composability 24

25 Composability 25

26 Composability 26

27 Observability (aka PCLSRing) 27

28 Observability (aka PCLSRing) 28

29 II. First-class Implementation protocol 29

30 Protocol: Categories class Cat s where type Arr s :: * dom :: (Arr s) s cod :: (Arr s) s composearr :: (Arr s) (Arr s) (Arr s) applyarr :: (Arr s) s s Usual functions: Effectful functions: 30

31 Protocol: Operational Semantics class (Cat s) OpSem s where run :: s Arr s done :: s Bool 31

32 Protocol: Operational Semantics class (Cat s) OpSem s where run :: s Arr s done :: s Bool eval :: s Arr s advance :: s Arr s 32

33 Protocol: Implementation class Impl a c where interpret :: c a mapinterpret :: (Arr c) (Arr a) So far, a functor from c to a 33

34 Protocol: Totality implement :: a c 34

35 Protocol: Completeness step :: c (Arr a) (Arr c) 35

36 Protocol: Liveness advanceinterpretation :: c Arr c 36

37 Protocol: Observability (PCLSRing) safepoint :: c Arr c 37

38 Compilation (1) implement :: (Impl a c) a c 38

39 Compilation (2) interpret :: (Impl a s) s a implement :: (Impl a c) a c 39

40 Compilation (3) u :: OpSem -- specify up to what rewrites interpret :: (Impl u s) s u implement :: (Impl u c) u c 40

41 Static Type Systems Subject reduction: T contains no exomorphisms 41

42 III. Applications of First-class Implementations 42

43 Migration 43

44 When your hammer is Migration... Process Migration Garbage Collection Zero Copy Routing Dynamic Configuration JIT Compilation etc. 44

45 Migration (Optimized) 45

46 Migration (Implemented) 46

47 Migration (Factored out) 47

48 Migration Tower 48

49 Semantic Tower 49

50 Optimistic Evaluation 50

51 Aspect-Oriented Programming (1) 51

52 Aspect-Oriented Programming (2) 52

53 Aspect-Oriented Programming (2) Constraint Logic Meta-programming! 53

54 Natural Transformations of Implementations 54

55 Natural Transformations of Implementations Automatic Instrumentation Code and Data Coverage Omniscient debugging Resource Accounting Parallelization Orthogonal persistence Virtualization etc. 55

56 IV. Runtime Meta-programming Architecture 56

57 Runtime Architecture 57

58 Runtime Architecture Development Platform (Emacs, IDE,...) User Interface Shell Operating System Distributed and Virtualized Application Management 58

59 Every Program has a Semantic Tower Semantics on top + Turtles all the way to the bottom Top specified by User, bottom controlled by System For the PLs your build, those you use Static or dynamic control 59

60 Every Tower has its Controller Runtime Meta-program, Shared (or not) Virtualization: control effects, connect I/O Reflective Tower of Meta-programs Another dimension to diagrams! Turtles? 60

61 Implicit I/O Input :: tag -> IO indata Output :: tag -> outdata -> IO () Handled by controller Virtualization of effects at language level Dynamically reconfigurable 61

62 Performance: Dynamic Global Optimization When configuration changes, migrate Optimize the current configuration Minimize encoding, Zero copy Skip unobserved computations 62

63 Simplicity: Separate program and metaprogram Example: File selector, UI, etc. Evolve, Distribute, Share, Configure separately Separate Capabilities, Semantics Robustness, Security: Smaller Attack Surface 63

64 Not Just a Library Semantic separation vs inclusion Bound at Runtime vs Fixed at Compile-/Load- time Different scopes and capabilities Different control flow 64

65 Related Works and Opportunities Formal Methods for proving program correctness Open Implementation, AOP... Many hacks for GC, Migration, Persistence... Virtualization, distribution... 65

66 Common Theme Programming in the Large, not in the Small Software Architecture that Scales Semantics matter Dimensions of Modularity beyond the usual 66

67 The Take Home Points (redux) Implementation is co-(abstract Interpretation) Safe points are a key concept First-class: the opposite of magic First-class safe points (= PCLSRing!) Applications: Migration, Optimistic Evaluation, etc. Composing implementations for fun and profit Runtime meta-programming brings new modularity 67

68 Challenge Put First-class Implementations in your platform Platform: PL, IDE, OS, Shell, Distributed System Factor your software into meta-levels Enjoy simplification, robustness, security 68

69 The Meta-Story My contribution is mostly not technical. It is more ambitious: 69

70 The Meta-Story My contribution is mostly not technical. It is more ambitious: A change of point of view about computing 70

71 The Meta-Story My contribution is mostly not technical. It is more ambitious: A change of point of view about computing Thank you! My blog: Houyhnhnm Computing 71