Late Data Layout - OOPLSA Talk

Late Data Layout talk at the OOPLSA research conference (Object-Oriented Programming, Systems, Languages & Applications). Website: http://2014.splashcon.org/event/oopsla2014-unifying-data-representation-transformations

Project website: http://scala-ldl.org

Transcript

1. scala-ldl.org Late Data Layout: Unifying Data Representation Transformations Vlad Ureche Eugene Burmako Martin Odersky École polytechnique fédérale de Lausanne, Switzerland {first.last}@epfl.ch 23rd of October 2014 OOPSLA '14 Portland, OR
2. scala-ldl.org Late Data Layout: Unifying Data Representation Transformations
3. scala-ldl.org Late Data Layout: Unifying Data Representation Transformations • compiler transformations • separate compilation • global scope
4. scala-ldl.org Late Data Layout: Unifying Data Representation Transformations • unboxing, value classes • how data is represented
5. scala-ldl.org Late Data Layout: Unifying Data Representation Transformations • what is there to unify? • why bother?
6. scala-ldl.org Motivation Transformation Conclusion Properties Benchmarks
7. scala-ldl.org Representation Transformations
8. scala-ldl.org Unboxing Primitive Types Representation Transformations
9. scala-ldl.org Unboxing Primitive Types Unboxing Primitive Types
10. scala-ldl.org Unboxing Primitive Types Unboxing Primitive Types int • value • no garbage collection • locality
11. scala-ldl.org Unboxing Primitive Types Unboxing Primitive Types • indirect access • object allocation • and thus garbage collection • no locality guarantees • compatible with erased generics java.lang.Integer int • value • no garbage collection • locality
12. scala-ldl.org Unboxing Primitive Types Unboxing Primitive Types • indirect access • object allocation • and thus garbage collection • no locality guarantees • compatible with erased generics java.lang.Integer in Java, programmers are responsible for the choice of representation int • value • no garbage collection • locality
13. scala-ldl.org Unboxing Primitive Types Unboxing Primitive Types • indirect access • object allocation • and thus garbage collection • no locality guarantees • compatible with erased generics java.lang.Integer in Java, programmers are responsible for the choice of representation What about Scala? int • value • no garbage collection • locality
14. scala-ldl.org Unboxing Primitive Types Unboxing Primitive Types • indirect access • object allocation • and thus garbage collection • no locality guarantees • compatible with erased generics java.lang.Integer int • value • no garbage collection • locality
15. scala-ldl.org Unboxing Primitive Types Unboxing Primitive Types • indirect access • object allocation • and thus garbage collection • no locality guarantees • compatible with erased generics java.lang.Integer int • value • no garbage collection • locality
16. scala-ldl.org Unboxing Primitive Types Unboxing Primitive Types • indirect access • object allocation • and thus garbage collection • no locality guarantees • compatible with erased generics java.lang.Integer int • value • no garbage collection • locality scala.Int
17. scala-ldl.org Unboxing Primitive Types Unboxing Primitive Types • indirect access • object allocation • and thus garbage collection • no locality guarantees • compatible with erased generics java.lang.Integer int • value • no garbage collection • locality scalac scala.Int
18. scala-ldl.org Unboxing Primitive Types Unboxing Primitive Types • indirect access • object allocation • and thus garbage collection • no locality guarantees • compatible with erased generics java.lang.Integer int • value • no garbage collection • locality scalac Choice of representation 1 scala.Int
19. scala-ldl.org Unboxing Primitive Types Unboxing Primitive Types • indirect access • object allocation • and thus garbage collection • no locality guarantees • compatible with erased generics java.lang.Integer int • value • no garbage collection • locality scalac Choice of representation 1 2 Coercions between representations scala.Int
20. scala-ldl.org Unboxing Primitive Types Value Classes Representation Transformations
21. scala-ldl.org Value Classes Value Classes
22. scala-ldl.org Value Classes Value Classes value class
23. scala-ldl.org Value Classes Value Classes value class struct (by-val) • preferred encoding • fields are inlined • no heap allocations
24. scala-ldl.org Value Classes Value Classes value class struct (by-val) • preferred encoding • fields are inlined • no heap allocations • fallback encoding • compatible with • subtyping • erased generics object (by-ref)
25. scala-ldl.org Value Classes Value Classes value class struct (by-val) • preferred encoding • fields are inlined • no heap allocations • fallback encoding • compatible with • subtyping • erased generics object (by-ref) scalac Choice of representation 1 2 Coercions between representations
26. scala-ldl.org Unboxing Primitive Types Value Classes Miniboxing Representation Transformations
27. scala-ldl.org Miniboxing Miniboxing OOPSLA '13
28. scala-ldl.org Miniboxing Miniboxing T (primitive)
29. scala-ldl.org Miniboxing Miniboxing long integer • preferred encoding • for all primitive types T (primitive)
30. scala-ldl.org Miniboxing Miniboxing long integer • preferred encoding • for all primitive types • fallback encoding • compatible with • virtual dispatch • subtyping • erased generics T (erased to Object) T (primitive)
31. scala-ldl.org Miniboxing Miniboxing long integer • preferred encoding • for all primitive types • fallback encoding • compatible with • virtual dispatch • subtyping • erased generics T (erased to Object) T (primitive) scalac Choice of representation 1 2 Coercions between representations
32. scala-ldl.org Unboxing Primitive Types Value Classes Representation Transformations Miniboxing
33. scala-ldl.org Unboxing Primitive Types Value Classes Representation Transformations Miniboxing motivated by erased generics
34. scala-ldl.org Unboxing Primitive Types Value Classes Representation Transformations Miniboxing motivated by erased generics Staging (Multi-Stage Programming)
35. scala-ldl.org Staging Staging Program Result 1+1+3 5 1-stage execution
36. scala-ldl.org Staging Staging Program Result 1+1+3 5 1-stage execution Program Program Result 2+3 1+1+3 5 2-stage execution
37. scala-ldl.org Staging Staging value
38. scala-ldl.org Staging Staging value direct value (5) • is a computed value • from an expression evaluated in the current stage
39. scala-ldl.org Staging Staging value direct value (5) • is a computed value • from an expression evaluated in the current stage • executed in the next stage • stores the expression that produces the value lifted expression (2+3)
40. scala-ldl.org scalac Staging Staging value direct value (5) • is a computed value • from an expression evaluated in the current stage • executed in the next stage • stores the expression that produces the value lifted expression (2+3) Choice of representation – domain-specific 1 2 Coercions between representations
41. scala-ldl.org Motivation Transformation Conclusion Properties Benchmarks
42. scala-ldl.org How to transform a program?
43. scala-ldl.org How to transform a program? We'll use primitive unboxing as the running example, to keep things simple
44. scala-ldl.org Syntax-based transformation Late Data Layout transformation
45. scala-ldl.org Syntax-based transformation Late Data Layout transformation
46. scala-ldl.org Syntax-based Syntax-based • we need coercions between representations • simple set of syntax-based rules – example
47. scala-ldl.org Syntax-based Syntax-based val x: Int = ... val y: Int = x
48. scala-ldl.org Syntax-based Syntax-based val x: Int = ... val y: Int = x
49. scala-ldl.org Syntax-based Syntax-based val x: Int = ... val y: Int = x val x: int = unbox(...) val y: Int = box(x)
50. scala-ldl.org Syntax-based Syntax-based val x: Int = ... val y: Int = x val x: int = unbox(...) val y: Int = box(x) Coerce the definition right-hand side
51. scala-ldl.org Syntax-based Syntax-based val x: Int = ... val y: Int = x val x: int = unbox(...) val y: Int = box(x) Coerce all occurences of the transformed value
52. scala-ldl.org Syntax-based Syntax-based val x: Int = ... val y: Int = x val x: int = unbox(...) val y: Int = box(x)
53. scala-ldl.org Syntax-based Syntax-based val x: Int = ... val y: Int = x val x: int = unbox(...) val y: Int = box(x) val x: int = unbox(...) val y: int = unbox(box(x))
54. scala-ldl.org Syntax-based Syntax-based val x: Int = ... val y: Int = x val x: int = unbox(...) val y: Int = box(x) val x: int = unbox(...) val y: int = unbox(box(x)) suboptimal
55. scala-ldl.org Peephole Optimization Peephole Optimization val y: int = unbox(box(x)) val y: int = x peephole
56. scala-ldl.org Syntax-based Syntax-based another example
57. scala-ldl.org Syntax-based Syntax-based def choice(t1: Int, t2: Int): Int = if (Random.nextBoolean()) t1 else t2
58. scala-ldl.org Syntax-based Syntax-based def choice(t1: Int, t2: Int): Int = if (Random.nextBoolean()) t1 else t2 Transform one by one
59. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: Int): Int = if (Random.nextBoolean()) box(t1) else t2
60. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): Int = if (Random.nextBoolean()) box(t1) else box(t2)
61. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): Int = if (Random.nextBoolean()) box(t1) else box(t2) Anything missing?
62. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): Int = if (Random.nextBoolean()) box(t1) else box(t2) Anything missing? Yes, unboxing the returned value
63. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): Int = if (Random.nextBoolean()) box(t1) else box(t2)
64. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): Int = if (Random.nextBoolean()) box(t1) else box(t2)
65. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): int = if (Random.nextBoolean()) box(t1) else box(t2)
66. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): int = unbox( if (Random.nextBoolean()) box(t1) else box(t2) )
67. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): int = unbox( if (Random.nextBoolean()) box(t1) else box(t2) )
68. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): int = unbox( if (Random.nextBoolean()) box(t1) else box(t2) )
69. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): int = unbox( if (Random.nextBoolean()) box(t1) else box(t2) ) new peephole rule
70. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): int = unbox( if (Random.nextBoolean()) box(t1) else box(t2) ) new peephole rule sink outside coercions into the if branches
71. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): int = if (Random.nextBoolean()) unbox(box(t1)) else unbox(box(t2))
72. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): int = if (Random.nextBoolean()) unbox(box(t1)) else unbox(box(t2))
73. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): int = if (Random.nextBoolean()) t1 else t2
74. scala-ldl.org Syntax-based Syntax-based def choice(t1: int, t2: int): int = if (Random.nextBoolean()) t1 else t2 complicated
75. scala-ldl.org Syntax-based Syntax-based • peephole transformation does not scale – needs multiple rewrite rules for each node – needs stateful rewrite rules – leads to an explosion of rules x states Details in the paper
76. scala-ldl.org Coercions are fixed in the tree
77. scala-ldl.org Coercions are fixed in the tree and moving them around is difficult.
78. scala-ldl.org Coercions are fixed in the tree and moving them around is difficult. We need a more fluid abstraction.
79. scala-ldl.org Coercions are fixed in the tree and moving them around is difficult. We need a more fluid abstraction. Types
80. scala-ldl.org Syntax-based transformation Late Data Layout transformation
81. scala-ldl.org Inject Coerce Commit Phases Late Data Layout transformation
82. scala-ldl.org LDL Transformation LDL Transformation • propagates representation information – into the type system • based on annotated types • e.g. an @unboxed annotation added to integers The Inject Phase The Inject Phase
83. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: Int, t2: Int): Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit
84. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit
85. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit depending on the transformation, other operations can be performed as well (e.g. miniboxing duplicates methods)
86. scala-ldl.org Inject Coerce Commit Phases Late Data Layout transformation
87. scala-ldl.org LDL Transformation LDL Transformation • introduces coercions – re-type-checks the tree – exposes representation mismatches • as annotation mismatches (Int vs @unboxed Int) • leading to coercions The Coerce Phase The Coerce Phase
88. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit
89. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit
90. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit the return type of choice is @unboxed Int
91. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit the return type of choice is @unboxed Int
92. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit : @unboxed Int the return type of choice is @unboxed Int
93. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit : @unboxed Int expected type (part of local type inference) the return type of choice is @unboxed Int
94. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit : @unboxed Int
95. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit : Boolean
96. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit : Boolean matches: expected: Boolean found: Boolean
97. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit : @unboxed Int
98. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit : @unboxed Int matches: expected: @unboxed Int found: @unboxed Int
99. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit : @unboxed Int
100. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit matches: ... : @unboxed Int
101. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit
102. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit LDL optimally transforms the tree the first time
103. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit LDL optimally transforms the tree the first time No peephole transformation
104. scala-ldl.org Inject Coerce Commit Phases Late Data Layout transformation
105. scala-ldl.org LDL Transformation LDL Transformation • converts annotations to representations – @unboxed Int → int – Int java.lang.Integer → • coercion markers are also transformed – box(...) → new Integer(...) – unbox(...) → ....intValue The Commit Phase The Commit Phase
106. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: @unboxed Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit
107. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: int, t2: int): int = if (Random.nextBoolean()) t1 else t2 inject coerce commit
108. scala-ldl.org LDL Transformation LDL Transformation def choice(t1: int, t2: int): int = if (Random.nextBoolean()) t1 else t2 inject coerce commit that's it!
109. scala-ldl.org Inject Coerce Commit Phases Late Data Layout transformation
110. scala-ldl.org Motivation Transformation Conclusion Properties Benchmarks
111. scala-ldl.org Selectivity Consistency Optimality (not formally proven yet) Properties Late Data Layout transformation
112. scala-ldl.org Selectivity Selectivity inject coerce commit • annotated types – selectively pick the representation for each value
113. scala-ldl.org Selectivity Selectivity inject coerce commit • annotated types – selectively pick the representation for each value • selectivity is used for – bridge methods (some args boxed, others unboxed) – value classes (JVM: no multi-value returns) – staging (representation: domain-specific knowledge) • List[Int] vs List[@staged Int] vs @staged List[Int]
114. scala-ldl.org Selectivity Selectivity def choice(t1: Int, t2: Int): Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit
115. scala-ldl.org Selectivity Selectivity def choice(t1: Int, t2: Int): Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit what if we did not annotate t1?
116. scala-ldl.org Selectivity Selectivity def choice(t1: Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit what if we did not annotate t1?
117. scala-ldl.org Selectivity Selectivity def choice(t1: Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit : @unboxed Int
118. scala-ldl.org Selectivity Selectivity def choice(t1: Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit : @unboxed Int
119. scala-ldl.org Selectivity Selectivity def choice(t1: Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit : @unboxed Int mismatch: expected: @unboxed Int found: Int
120. scala-ldl.org Selectivity Selectivity def choice(t1: Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) t1 else t2 inject coerce commit : @unboxed Int mismatch: expected: @unboxed Int found: Int coercion
121. scala-ldl.org Selectivity Selectivity def choice(t1: Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) unbox(t1) else t2 inject coerce commit
122. scala-ldl.org Selectivity Selectivity def choice(t1: Int, t2: @unboxed Int): @unboxed Int = if (Random.nextBoolean()) unbox(t1) else t2 inject coerce commit
123. scala-ldl.org Selectivity Selectivity def choice(t1: java.lang.Integer, t2: int): int = if (Random.nextBoolean()) t1.intValue else t2 inject coerce commit
124. scala-ldl.org Selectivity Consistency Optimality (not formally proven yet) Properties Late Data Layout transformation
125. scala-ldl.org Consistency Consistency inject coerce commit • representations become part of types • re-type-checking the program – proves type correctness – proves representation consistency
126. scala-ldl.org Selectivity Consistency Optimality (not formally proven yet) Properties Late Data Layout transformation
127. scala-ldl.org Optimality Optimality def choice(t1: java.lang.Integer, t2: int): int = if (Random.nextBoolean()) t1.intValue else t2 inject coerce commit
128. scala-ldl.org Optimality Optimality def choice(t1: java.lang.Integer, t2: int): int = if (Random.nextBoolean()) t1.intValue else t2 execution inject coerce commit
129. scala-ldl.org Optimality Optimality def choice(t1: java.lang.Integer, t2: int): int = if (Random.nextBoolean()) t1.intValue else t2 1 coercion execution inject coerce commit
130. scala-ldl.org Optimality Optimality def choice(t1: java.lang.Integer, t2: int): int = if (Random.nextBoolean()) t1.intValue else t2 1 coercion no coercions execution inject coerce commit
131. scala-ldl.org Optimality Optimality • on any execution trace through the program – the number of coercions executed is minimum – assuming the program terminates inject coerce commit
132. scala-ldl.org Optimality Optimality • on any execution trace through the program – the number of coercions executed is minimum – assuming the program terminates • modulo – annotations introduced by the inject phase • unbox both parameters → no coercions at all inject coerce commit
133. scala-ldl.org Optimality Optimality • on any execution trace through the program – the number of coercions executed is minimum – assuming the program terminates • modulo – annotations introduced by the inject phase • unbox both parameters → no coercions at all – post-transformations done by the commit phase • box(...) → new Integer(new Integer(...).intValue) inject coerce commit
134. scala-ldl.org Optimality Optimality • peephole optimization – propagates coercions • type system – propagates types inject coerce commit
135. scala-ldl.org Optimality Optimality • peephole optimization – propagates coercions • type system – propagates types – but types are fluid whereas coercions are not details in the paper inject coerce commit
136. scala-ldl.org Selectivity Consistency Optimality (not formally proven yet) Properties Late Data Layout transformation
137. scala-ldl.org Motivation Transformation Conclusion Properties Benchmarks
138. scala-ldl.org LDL is used in LDL is used in • Scala compiler plugins – miniboxing (specialization) – value-class plugin – staging plugin
139. scala-ldl.org Benchmarks Benchmarks … … in the paper in the paper • implementation effort – Late Data Layout mechanism • developed as part of miniboxing • reused by the other compiler plugins – value class plugin → 2 developer-weeks – staging plugin → 1 developer-week
140. scala-ldl.org Benchmarks Benchmarks … … in the paper in the paper • performance – baseline vs transformed code • numbers – up to 2x speedup when transforming value classes – up to 22x speedup when using miniboxing – up to 59x speedup when staging
141. scala-ldl.org Motivation Transformation Conclusion Properties Benchmarks
142. scala-ldl.org Conclusion Conclusion Insights Insights • use annotated types – to selectively mark values with the representation • use expected type propagation – to provide optimal transformation • use the type system – to provide representation consistency
143. scala-ldl.org Credits and Thank you-s • Cristian Talau - developed the initial prototype, as a semester project • Eugene Burmako - the value class plugin based on the LDL transformation • Aymeric Genet - developing collection-like benchmarks for the miniboxing plugin • Martin Odersky, for his patient guidance • Eugene Burmako, for trusting the idea enough to develop the value-plugin based on the LDL transformation • Iulian Dragos, for his work on specialization and many explanations • Miguel Garcia, for his original insights that spawned the miniboxing idea • Michel Schinz, for his wonderful comments and enlightening ACC course • Andrew Myers and Roland Ducournau for the discussions we had and the feedback provided • Heather Miller for the eye-opening discussions we had • Vojin Jovanovic, Sandro Stucki, Manohar Jonalagedda and the whole LAMP laboratory in EPFL for the extraordinary atmosphere • Adriaan Moors, for the miniboxing name which stuck :)) • Thierry Coppey, Vera Salvisberg and George Nithin, who patiently listened to many presentations and provided valuable feedback • Grzegorz Kossakowski, for the many brainstorming sessions on specialization • Erik Osheim, Tom Switzer and Rex Kerr for their guidance on the Scala community side • OOPSLA paper and artifact reviewers, who reshaped the paper with their feedback • Sandro, Vojin, Nada, Heather, Manohar - reviews and discussions on the LDL paper • Hubert Plociniczak for the type notation in the LDL paper • Denys Shabalin, Dmitry Petrashko for their patient reviews of the LDL paper • Xiaoya Xiang and Philip Stutz for trusting miniboxing enough to try it out Special thanks to the Scala Community for their support! (@StuHood, @vpatryshev and everyone else!)
144. scala-ldl.org concept repr. 1 … repr. n repr. 2
145. scala-ldl.org concept repr. 1 … repr. n repr. 2 How would you use this?
146. scala-ldl.org Thank you! concept repr. 1 … repr. n repr. 2 How would you use this?