Data-centric Metaprogramming @ VMM 2015

The data-centric metaprogramming presentation at the VMM '15 (Virtual Machine Meetup), Zurich, Switzerland. Website: http://vmmeetup.github.io/2015/

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

1. scala-ildl.org 11th of September 2015 Virtual Machines Meetup Zürich, Switzerland Data-centric Metaprogramming
2. scala-ildl.org STOP Please ask if things are not clear!
3. scala-ildl.org Vlad URECHE PhD student in the Scala Team @ EPFL Working on program transformations focusing on data representation. Miniboxing guy. Scala compiler geek. @ @VladUreche @VladUreche vlad.ureche@epfl.ch
4. scala-ildl.org Data-centric Metaprogramming
5. scala-ildl.org Data-centric Metaprogramming Joint work with • Martin Odersky • Aggelos Biboudis • Yannis Smaragdakis
6. scala-ildl.org infoscience.epfl.ch/record/207050
7. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work
8. scala-ildl.org Data-centric Metaprogramming
9. scala-ildl.org Data-centric Metaprogramming ... in Object-Oriented Languages
10. scala-ildl.org Object Composition Object Composition class Vector[T] { … }
11. scala-ildl.org Object Composition Object Composition class Vector[T] { … } The Vector collection in the Scala library
12. scala-ildl.org Object Composition Object Composition class Employee(...) ID NAME SALARY class Vector[T] { … } The Vector collection in the Scala library
13. scala-ildl.org Object Composition Object Composition class Employee(...) ID NAME SALARY Auto-generated, corresponds to a table row class Vector[T] { … } The Vector collection in the Scala library
14. scala-ildl.org Object Composition Object Composition class Vector[T] { … } class Employee(...) ID NAME SALARY
15. scala-ildl.org Object Composition Object Composition class Vector[T] { … } class Employee(...) ID NAME SALARY
16. scala-ildl.org Object Composition Object Composition class Employee(...) ID NAME SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY class Vector[T] { … }
17. scala-ildl.org Object Composition Object Composition class Employee(...) ID NAME SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY class Vector[T] { … } Traversal requires dereferencing a pointer for each employee.
18. scala-ildl.org A Better Representation A Better Representation Vector[Employee] ID NAME SALARY ID NAME SALARY
19. scala-ildl.org A Better Representation A Better Representation NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY
20. scala-ildl.org A Better Representation A Better Representation NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY iteration is 5x faster
21. scala-ildl.org A Better Representation A Better Representation NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY iteration is 5x faster C++ would produce a better representation here, but there are still cases where the C++ representation could be improved over.
22. scala-ildl.org A Better Representation A Better Representation • In isolation Vector[T] and Employee are optimal
23. scala-ildl.org A Better Representation A Better Representation • In isolation Vector[T] and Employee are optimal • Together, Vector[Employee] can be optimized
24. scala-ildl.org A Better Representation A Better Representation • In isolation Vector[T] and Employee are optimal • Together, Vector[Employee] can be optimized Challenge: No means of communicating this to the compiler
25. scala-ildl.org A Better Representation A Better Representation • In isolation Vector[T] and Employee are optimal • Together, Vector[Employee] can be optimized Challenge: No means of communicating this to the compiler You may disagree. We'll have a related work section later.
26. scala-ildl.org
27. scala-ildl.org • Transforming the code by hand – Makes maintenance difficult – Changes are not contained
28. scala-ildl.org • Transforming the code by hand – Makes maintenance difficult – Changes are not contained Can we automate this?
29. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work
30. scala-ildl.org Transformation Transformation Definition Application
31. scala-ildl.org Transformation Transformation Definition Application • can't be automated • based on experience • based on speculation • one-time effort
32. scala-ildl.org Transformation Transformation Definition Application • can't be automated • based on experience • based on speculation • one-time effort programmer
33. scala-ildl.org Transformation Transformation Definition Application • can't be automated • based on experience • based on speculation • one-time effort • repetitive and simple • affects code readability • is verbose • is error-prone programmer
34. scala-ildl.org Transformation Transformation programmer Definition Application • can't be automated • based on experience • based on speculation • one-time effort • repetitive and simple • affects code readability • is verbose • is error-prone compiler (automated)
35. scala-ildl.org Transformation Transformation programmer Definition Application • can't be automated • based on experience • based on speculation • one-time effort • repetitive and simple • affects code readability • is verbose • is error-prone compiler (automated)
36. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { ... }
37. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { ... } An object that describes a Transformation.
38. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { ... } An object that describes a Transformation. A marker trait for transformations.
39. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { ... }
40. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { ... } What does the compiler need to know?
41. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { ... } What does the compiler need to know? The target of the transformation and its representation.
42. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { type Target = Vector[Employee] type Result = EmployeeVector ... }
43. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { type Target = Vector[Employee] type Result = EmployeeVector ... } The transformation is type-driven we indicate → the type of the target and of the representation.
44. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { type Target = Vector[Employee] type Result = EmployeeVector ... } The transformation is type-driven we indicate → the type of the target and of the representation. The improved representation is defined in the host language.
45. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { type Target = Vector[Employee] type Result = EmployeeVector ... }
46. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { type Target = Vector[Employee] type Result = EmployeeVector ... } How to transform Vector[Employee] into an EmployeeVector?
47. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { type Target = Vector[Employee] type Result = EmployeeVector def toResult(t: Target): Result = ... def toTarget(t: Result): Target = ... ... }
48. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { type Target = Vector[Employee] type Result = EmployeeVector def toResult(t: Target): Result = ... def toTarget(t: Result): Target = ... ... } Conversions to/from Vector[Employee] that consume/produce a EmployeeVector?
49. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { type Target = Vector[Employee] type Result = EmployeeVector def toResult(t: Target): Result = ... def toTarget(t: Result): Target = ... ... }
50. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { type Target = Vector[Employee] type Result = EmployeeVector def toResult(t: Target): Result = ... def toTarget(t: Result): Target = ... ... } So far so good, but how to execute Vector[Employee] operations on EmployeeVector?
51. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation { type Target = Vector[Employee] type Result = EmployeeVector def toResult(t: Target): Result = ... def toTarget(t: Result): Target = ... def bypass_length: Int = ... def bypass_apply(i: Int): Employee = ... def bypass_update(i: Int, v: Employee) = ... def bypass_toString: String = ... ... }
52. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming programmer Definition Application • can't be automated • based on experience • based on speculation • one-time effort • repetitive and simple • affects code readability • is verbose • is error-prone compiler (automated)
53. scala-ildl.org Transformation Transformation programmer Definition Application • can't be automated • based on experience • based on speculation • one-time effort • repetitive and simple • affects code readability • is verbose • is error-prone compiler (automated)
54. scala-ildl.org Transformation Transformation programmer Definition Application • can't be automated • based on experience • based on speculation • one-time effort • repetitive and simple • affects code readability • is verbose • is error-prone compiler (automated) In the paper
55. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work
56. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best Represenation? Composition
57. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best Represenation? Composition
58. scala-ildl.org Open World Assumption Open World Assumption class Vector[T] { … } class Employee(...) ID NAME SALARY
59. scala-ildl.org Open World Assumption Open World Assumption class Vector[T] { … } class Employee(...) ID NAME SALARY
60. scala-ildl.org Open World Assumption Open World Assumption class Employee(...) ID NAME SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY class Vector[T] { … }
61. scala-ildl.org Open World Assumption Open World Assumption class Employee(...) ID NAME SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY class Vector[T] { … } NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY
62. scala-ildl.org Open World Assumption Open World Assumption class Employee(...) ID NAME SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY class Vector[T] { … } NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY class NewEmployee(...) extends Employee(...) ID NAME SALARY DEPT
63. scala-ildl.org Open World Assumption Open World Assumption class Employee(...) ID NAME SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY class Vector[T] { … } NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY class NewEmployee(...) extends Employee(...) ID NAME SALARY DEPT Oooops...
64. scala-ildl.org Open World Assumption Open World Assumption • Globally anything can happen
65. scala-ildl.org Open World Assumption Open World Assumption • Globally anything can happen • Locally the programmer has full control: – Knows the values that will be used – Can reject non-conforming values
66. scala-ildl.org Open World Assumption Open World Assumption • Globally anything can happen • Locally the programmer has full control: – Knows the values that will be used – Can reject non-conforming values How to use this information?
67. scala-ildl.org Open World Assumption Open World Assumption • Globally anything can happen • Locally the programmer has full control: – Knows the values that will be used – Can reject non-conforming values How to use this information? Scopes
68. scala-ildl.org Scopes Scopes def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary )
69. scala-ildl.org Scopes Scopes def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) Method operating on Scala collections (familiar to programmers)
70. scala-ildl.org Scopes Scopes def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary )
71. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeOpt) { def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) }
72. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeOpt) { def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) } Now the method operates on the EmployeeVector representation.
73. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeOpt) { def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) } Now the method operates on the EmployeeVector representation. Programmers can freely choose which parts of their code to transform.
74. scala-ildl.org Scopes Scopes • Can wrap statements, methods even entire classes – Inlined immediately after the parser – Definitions are visible outside the "scope"
75. scala-ildl.org Scopes Scopes • Can wrap statements, methods even entire classes – Inlined immediately after the parser – Definitions are visible outside the "scope" • Locally closed world – Incoming/outgoing values go through conversions – Programmer can reject unexpected values
76. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best Represenation? Composition
77. scala-ildl.org Best Representation Best Representation Vector[Employee] ID NAME SALARY ID NAME SALARY
78. scala-ildl.org Best ...? Best ...? NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY
79. scala-ildl.org Best ...? Best ...? NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY CompactVector <compressed binary blob>
80. scala-ildl.org Best ...? Best ...? NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY EmployeeJSON { id: 123, name: “John Doe” salary: 100 } CompactVector <compressed binary blob>
81. scala-ildl.org Best ...? Best ...? NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY EmployeeJSON { id: 123, name: “John Doe” salary: 100 } CompactVector <compressed binary blob> Scopes!
82. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeOpt) { def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) }
83. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeOpt) { def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) } Method operating on column-based storage
84. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeBinary) { def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) } Method operating on binary data
85. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeJSON) { def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) } Method operating on JSON data
86. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best Represenation? Composition
87. scala-ildl.org Scope Composition Scope Composition • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
88. scala-ildl.org Scope Composition Scope Composition calling • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
89. scala-ildl.org Scope Composition Scope Composition calling • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
90. scala-ildl.org Scope Composition Scope Composition calling • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations Coercions
91. scala-ildl.org Scope Composition Scope Composition calling • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations Coercions
92. scala-ildl.org Scope Composition Scope Composition calling • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
93. scala-ildl.org Scope Composition Scope Composition calling • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
94. scala-ildl.org Scope Composition Scope Composition calling • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations No coercions
95. scala-ildl.org Scope Composition Scope Composition calling • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations No coercions Even across separate compilation
96. scala-ildl.org Scope Composition Scope Composition calling • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
97. scala-ildl.org Scope Composition Scope Composition calling • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
98. scala-ildl.org Scope Composition Scope Composition calling • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations Two coercions Repr1 Target Repr2 → →
99. scala-ildl.org Scope Composition Scope Composition calling • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
100. scala-ildl.org Scope Composition Scope Composition calling overriding • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
101. scala-ildl.org Scope Composition Scope Composition calling overriding • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations The transformation has to preserve the object model.
102. scala-ildl.org Scope Composition Scope Composition calling overriding • Original code • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations The transformation has to preserve the object model. Handled automatically by the ildl transformation!
103. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best Represenation? Composition
104. scala-ildl.org Array of Stuct Array of Stuct (Column-oriented) (Column-oriented) NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY
105. scala-ildl.org Array of Stuct Array of Stuct (Column-oriented) (Column-oriented) NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY 5x faster
106. scala-ildl.org Specialization Specialization and stack allocation and stack allocation 3 5 (3,5) Tuples in Scala are generic so they need to use pointers and objects
107. scala-ildl.org Specialization Specialization and stack allocation and stack allocation 3 5 3 5 (3,5) (3,5) Tuples in Scala are generic so they need to use pointers and objects + stack allocation
108. scala-ildl.org + stack allocation Specialization Specialization and stack allocation and stack allocation 14x faster reduced memory footprint 3 5 3 5 (3,5) (3,5) Tuples in Scala are generic so they need to use pointers and objects
109. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum
110. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4)
111. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8)
112. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8) 18
113. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8) 18
114. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8) 18 transform(ListDeforestation) { List(1,2,3).map(_ + 1).map(_ * 2).sum }
115. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8) 18 transform(ListDeforestation) { List(1,2,3).map(_ + 1).map(_ * 2).sum } accumulate function
116. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8) 18 transform(ListDeforestation) { List(1,2,3).map(_ + 1).map(_ * 2).sum } accumulate function accumulate function
117. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8) 18 transform(ListDeforestation) { List(1,2,3).map(_ + 1).map(_ * 2).sum } accumulate function accumulate function compute: 18
118. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8) 18 transform(ListDeforestation) { List(1,2,3).map(_ + 1).map(_ * 2).sum } accumulate function accumulate function compute: 18 6x faster
119. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best Represenation? Composition
120. scala-ildl.org Multi-Stage Programming Multi-Stage Programming • Multi-Stage Programming – “Abstraction without regret” - Tiark Rompf – DSLs small enough to be staged → • 10000x speed improvements
121. scala-ildl.org Multi-Stage Programming Multi-Stage Programming • Multi-Stage Programming – “Abstraction without regret” - Tiark Rompf – DSLs small enough to be staged → • 10000x speed improvements – Scala many features not supported by LMS: → • Separate compilation/modularization • Dynamic dispatch • Aliasing • Reflection
122. scala-ildl.org Multi-Stage Programming Multi-Stage Programming • Multi-Stage Programming – “Abstraction without regret” - Tiark Rompf – DSLs small enough to be staged → • 10000x speed improvements – Scala many features not supported by LMS: → • Separate compilation/modularization • Dynamic dispatch • Aliasing • Reflection If we add support, we lose the ability to optimize code :(
123. scala-ildl.org Low-level Optimizers Low-level Optimizers • JIT optimizers with virtual machine support – Access to the low-level code – Can assume a (local) closed world – Can speculate based on profiles – On the critical path – limited analysis
124. scala-ildl.org Low-level Optimizers Low-level Optimizers • JIT optimizers with virtual machine support – Access to the low-level code – Can assume a (local) closed world – Can speculate based on profiles – On the critical path – limited analysis – Biggest opportunities are high-level - O(n2) O(n) → • Incoming code is low-level • Rarely possible to recover opportunities
125. scala-ildl.org Low-level Optimizers Low-level Optimizers • JIT optimizers with virtual machine support – Access to the low-level code – Can assume a (local) closed world – Can speculate based on profiles – On the critical path – limited analysis – Biggest opportunities are high-level - O(n2) O(n) → • Incoming code is low-level • Rarely possible to recover opportunities Typical solution: Metaprogramming
126. scala-ildl.org Metaprogramming Metaprogramming • Not your grandpa's C preprocessor def optimize(tree: AST): AST = { ... }
127. scala-ildl.org Metaprogramming Metaprogramming • Not your grandpa's C preprocessor • Full-fledged program transformers – :) Lots of power def optimize(tree: AST): AST = { ... }
128. scala-ildl.org Metaprogramming Metaprogramming • Not your grandpa's C preprocessor • Full-fledged program transformers – :) Lots of power – :( Lots of responsibility def optimize(tree: AST): AST = { ... }
129. scala-ildl.org Metaprogramming Metaprogramming • Not your grandpa's C preprocessor • Full-fledged program transformers – :) Lots of power – :( Lots of responsibility • Compiler invariants • Object-oriented model • Modularity def optimize(tree: AST): AST = { ... }
130. scala-ildl.org Metaprogramming Metaprogramming • Not your grandpa's C preprocessor • Full-fledged program transformers – :) Lots of power – :( Lots of responsibility • Compiler invariants • Object-oriented model • Modularity def optimize(tree: AST): AST = { ... } Can we make metaprogramming “high-level”?
131. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best Represenation? Composition
132. scala-ildl.org Conclusion Conclusion • Object-oriented composition inefcient representation → • Solution: data-centric metaprogramming – Splitting the responsibility: • Defining the Transformation programmer → • Applying the Transformation compiler → – Scopes • Adapt the data representation to the operation • Allow speculating properties of the scope • We've just begun to scratch the surface – Many interesting research questions lie ahead
133. scala-ildl.org Conclusion Conclusion • Object-oriented composition inefcient representation → • Solution: data-centric metaprogramming – Splitting the responsibility: • Defining the Transformation programmer → • Applying the Transformation compiler → – Scopes • Adapt the data representation to the operation • Allow speculating properties of the scope • We've just begun to scratch the surface – Many interesting research questions lie ahead
134. scala-ildl.org Conclusion Conclusion • Object-oriented composition inefcient representation → • Solution: data-centric metaprogramming – Splitting the responsibility: • Defining the Transformation programmer → • Applying the Transformation compiler → – Scopes • Adapt the data representation to the operation • Allow speculating properties of the scope • We've just begun to scratch the surface – Many interesting research questions lie ahead
135. scala-ildl.org Conclusion Conclusion • Object-oriented composition inefcient representation → • Solution: data-centric metaprogramming – Splitting the responsibility: • Defining the Transformation programmer → • Applying the Transformation compiler → – Scopes • Adapt the data representation to the operation • Allow speculating properties of the scope • We've just begun to scratch the surface – Many interesting research questions lie ahead
136. scala-ildl.org infoscience.epfl.ch/record/207050
137. scala-ildl.org github.com/miniboxing/ildl-plugin
138. scala-ildl.org github.com/miniboxing/ildl-plugin
139. scala-ildl.org github.com/miniboxing/ildl-plugin Examples of data-centric metaprogramming applications
140. scala-ildl.org
141. scala-ildl.org Thank you!