Combining Deep and Shallow Embedding for EDSL

“…Based on ideas from polytypic programming [41,83,77] we introduce a type class Iso[T], which defines a mapping between Vec and the Rep types it consists of:…”

Section: First-class Now Second-class Latermentioning

confidence: 99%

LMS-Verify: abstraction without regret for verified systems programming

Amin

Rompf

2017

Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages

View full text Add to dashboard Cite

Performance critical software is almost always developed in C, as programmers do not trust high-level languages to deliver the same reliable performance. This is bad because low-level code in unsafe languages attracts security vulnerabilities and because development is far less productive, with PL advances mostly lost on programmers operating under tight performance constraints. Highlevel languages provide memory safety out of the box, but they are deemed too slow and unpredictable for serious system software.Recent years have seen a surge in staging and generative programming: the key idea is to use high-level languages and their abstraction power as glorified macro systems to compose code fragments in first-order, potentially domain-specific, intermediate languages, from which fast C can be emitted. But what about security? Since the end result is still C code, the safety guarantees of the high-level host language are lost.In this paper, we extend this generative approach to emit ACSL specifications along with C code. We demonstrate that staging achieves "abstraction without regret" for verification: we show how high-level programming models, in particular higher-order composable contracts from dynamic languages, can be used at generation time to compose and generate first-order specifications that can be statically checked by existing tools. We also show how type classes can automatically attach invariants to data types, reducing the need for repetitive manual annotations.We evaluate our system on several case studies that varyingly exercise verification of memory safety, overflow safety, and functional correctness. We feature an HTTP parser that is (1) fast (2) high-level: implemented using staged parser combinators (3) secure: with verified memory safety. This result is significant, as input parsing is a key attack vector, and vulnerabilities related to HTTP parsing have been documented in all widely-used web servers.

show abstract

“…LMS is called lightweight because it is implemented as a library instead of baked-in into a language, and it is called modular because there is complete freedom to define the available operations on Rep Another way to look at this structure is as combining a shallow and a deep embedding for an IR object language [21]. Methods like infix_+ can serve as smart constructors that perform optimizations on the fly while building the IR [18].…”

Section: Futamura Projectionsmentioning

confidence: 99%

Functional pearl: a SQL to C compiler in 500 lines of code

RompfTiark

AminNada²

2015

SIGPLAN Not.

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 highlevel 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 towards generative programming. The core of the query engine is an interpreter for relational algebra operations, written in Scala. Using the opensource LMS Framework (Lightweight Modular Staging), 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 known as Futamura projections, which state that a program that can specialize an interpreter to any given input program is equivalent to a compiler.In this pearl, we discuss LMS programming patterns such as mixed-stage data structures (e.g. data records with static schema and dynamic field components) and techniques to generate lowlevel C code, including specialized data structures and data loading primitives.

show abstract

Combining Deep and Shallow Embedding for EDSL

Cited by 50 publications

References 15 publications

Type-and-scope safe programs and their proofs

Type-and-scope safe programs and their proofs

LMS-Verify: abstraction without regret for verified systems programming

Functional pearl: a SQL to C compiler in 500 lines of code

Contact Info

Product

Resources

About