Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Late Data Layout - OOPLSA Talk

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

456d1d6154efe50e950b65f966f63a50?s=128

Vlad Ureche

October 23, 2014
Tweet

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?