Reflections on LMS: exploring front-end alternatives

Rompf, Tiark

doi:10.1145/2998392.2998399

Cited by 11 publications

(7 citation statements)

References 90 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Various patterns for realizing program transformations for increased performance through generative programming have been identified by the high-performance-computing community (Cohen et al, 2006;Ofenbeck et al, 2017), but there is comparatively fewer work in the context of systems-oriented software. The essence of LMS has been described as a combination of techniques such as operator overloading and eager let-insertion (Rompf, 2016a(Rompf, , 2016b, which can be realized in different ways in both statically and dynamically typed languages (Amin & Rompf, 2018;Moldovan et al, 2019).…”

Section: Generative Programmingmentioning

confidence: 99%

A SQL to C compiler in 500 lines of code

Rompf¹,

Amin²

2019

J. Funct. Prog.

Self Cite

View full text Add to dashboard Cite

We present the design and implementation of a SQL query processor that outperforms existing database systems and is written in just about 500 lines of Scala code – a convincing case study that high-level functional programming can handily beat C for systems-level programming where the last drop of performance matters. The key enabler is a shift in perspective toward generative programming. The core of the query engine is an interpreter for relational-algebra operations, written in Scala. Using the open-source lightweight modular staging framework, we turn this interpreter into a query compiler with very low effort. To do so, we capitalize on an old and widely known result from partial evaluation: the first Futamura projection, which states that a process that can specialize an interpreter to any given input program is equivalent to a compiler. In this context, we discuss lightweight modular staging programming patterns such as mixed-stage data structures (e.g., data records with static schema and dynamic field components) and techniques to generate low-level C code, including specialized data structures and data loading primitives.

show abstract

Section: Generative Programmingmentioning

confidence: 99%

A SQL to C compiler in 500 lines of code

Rompf¹,

Amin²

2019

J. Funct. Prog.

Self Cite

View full text Add to dashboard Cite

show abstract

“…(For example, MVCs [37] and Torgersen's second solution [34] both have the same issue.) The state of affairs for LMS might change in future though [38].…”

Section: E3 Upon Extension Forces No Manipulation or Duplicationmentioning

confidence: 99%

Composition of Languages Embedded in Scala

Haeri

Keir

2019

Proceedings of the 2019 Federated Conference on Computer Science and Information Systems

View full text Add to dashboard Cite

Composition is amongst the major challenges faced in language engineering. Erdweg et al. offered a taxonomy for language composition. Mernik catalogued the use of the Language Definitional Framework LISA for composition sorts in that taxonomy. We produce a similar catalogue for embedded language engineering in Scala. We begin with techniques that are not specific to Scala. They are applicable in any host language with a module system and support for higher order functions. We, then, present two more techniques to examine Scala-specific language engineering. Interestingly enough, even though dealing with embedded languages, in terms of lines of code, our material is of comparable length to its LISA counterpart. Our work lends insight into Scala's serviceability for composition, as a host for embedded language engineering.

show abstract

“…However, these are often heavyweight and impose a significant cost on domain experts, who have to deal with complicated type encodings, whereas they would just like to express code transformations as simple rewrite rules. In particular, we found that GADTs are hard to manipulate in systems like Haskell and Scala [Giarrusso 2013;Rompf 2016]. łType-based embeddingž systems like LMS [Rompf and Odersky 2010] use implicit conversions to compose code fragments, but this approach is complicated [Jovanovic et al 2014] and is not applicable to code pattern-matching.…”

Section: Safe Program Manipulationmentioning

confidence: 99%

Unifying analytic and statically-typed quasiquotes

Parreaux

Voizard

Shaikhha

et al. 2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Metaprograms are programs that manipulate (generate, analyze and evaluate) other programs. These tasks are greatly facilitated by quasiquotation, a technique to construct and deconstruct program fragments using quoted code templates expressed in the syntax of the manipulated language. We argue that two main flavors of quasiquotes have existed so far: Lisp-style quasiquotes, which can both construct and deconstruct programs but may produce code that contains type mismatches and unbound variables; and MetaML-style quasiquotes, which rely on static typing to prevent these errors, but can only construct programs. In this paper, we show how to combine the advantages of both flavors into a unified framework: we allow the construction, deconstruction and evaluation of program fragments while ensuring that generated programs are well-typed and well-scoped, a combination unseen in previous work. We formalize our approach as λ { } , a multi-stage calculus with code pattern matching and rewriting, and prove its type safety. We also present its realization in Squid, a metaprogramming framework for Scala, leveraging Scala's expressive type system. To demonstrate the usefulness of our approach, we introduce speculative rewrite rules, a novel code transformation technique that makes decisive use of these capabilities, and we outline how it simplifies the design of some crucial query compiler optimizations. CCS Concepts: • Software and its engineering → Language features; Semantics;

show abstract

Reflections on LMS: exploring front-end alternatives

Cited by 11 publications

References 90 publications

A SQL to C compiler in 500 lines of code

A SQL to C compiler in 500 lines of code

Composition of Languages Embedded in Scala

Unifying analytic and statically-typed quasiquotes

Contact Info

Product

Resources

About