Languages as libraries

Tobin-Hochstadt, Sam; St-Amour, Vincent; Culpepper, Ryan; Flatt, Matthew; Felleisen, Matthias

doi:10.1145/1993498.1993514

Cited by 105 publications

(11 citation statements)

References 30 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…More generally, we argue for a radical rethinking of the role of high-level languages in performance critical code [16]. While our work demonstrates that Scala is a good choice, other expressive modern languages can be used just as well, as demonstrated by Racket macros [23], DSLs Accelerate [12], Feldspar [1], Nikola [11] (Haskell), Copperhead [2] (Python), Terra [4,5] (Lua).…”

Section: Perspectivesmentioning

confidence: 96%

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

Section: Perspectivesmentioning

confidence: 96%

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

RompfTiark

AminNada²

2015

SIGPLAN Not.

View full text Add to dashboard Cite

show abstract

“…There are various metaprogramming techniques varying from preprocessors, templates as in C ++ or D, program generators 6 [e.g. Pronk et al 2013;Rathgeber et al 2017], JIT-compilation techniques like PACXX [Haidl et al 2016], quotation-based approaches like MetaML [Taha and Sheard 2000], MetaOCaml [Kiselyov 2014] (see Figure 3a), Terra [DeVito et al 2013] (see Figure 3b), or quasiquotation in Lisp [Bawden 1999], hygienic macro systems [Kohlbecker et al 1986] like Racket [Tobin-Hochstadt et al 2011], to deep DSL embedding (see below). MetaML and MetaOCaml stand out because unlike most other metaprogramming techniques their type systems ensure soundness of the multi-stage execution.…”

Section: Metaprogrammingmentioning

confidence: 99%

AnyDSL: a partial evaluation framework for programming high-performance libraries

Leißa

Boesche

Hack

et al. 2018

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

This paper advocates programming high-performance code using partial evaluation. We present a clean-slate programming system with a simple, annotation-based, online partial evaluator that operates on a CPS-style intermediate representation. Our system exposes code generation for accelerators (vectorization/parallelization for CPUs and GPUs) via compiler-known higher-order functions that can be subjected to partial evaluation. This way, generic implementations can be instantiated with target-specific code at compile time. In our experimental evaluation we present three extensive case studies from image processing, ray tracing, and genome sequence alignment. We demonstrate that using partial evaluation, we obtain high-performance implementations for CPUs and GPUs from one language and one code base in a generic way. The performance of our codes is mostly within 10%, often closer to the performance of multi man-year, industry-grade, manuallyoptimized expert codes that are considered to be among the top contenders in their fields. CCS Concepts: • Software and its engineering → Compilers; Parallel programming languages; • Hardware → Emerging languages and compilers; • Computing methodologies → Image processing; Ray tracing; • Applied computing → Bioinformatics;

show abstract

Section: Evaluating On Existing Benchmarksmentioning

confidence: 99%

“…The table shows total line count (excluding blank lines and comments) and the number of static occurrences of contracts and primitives requiring dynamic checks such as function applications and primitive operations. These checks can be eliminated if we can show that they never fail; this has proven to produce significant speedups in practice, even without eliminating more expensive contract checks (Tobin-Hochstadt et al 2011).The table reports time (in milliseconds) and the number of false positives for SCV and our reduced system omitting the key contributions of this work (labeled "Simple"); "∞" indicates a timeout after 5 minutes.A false positive is a contract violation reported by the analysis, but by human inspection, cannot happen. The programs we consider are all known not to have contract errors, and thus all potential errors are false positives.…”

mentioning

confidence: 99%

Soft contract verification

Nguyen

Tobin-Hochstadt

Horn

2014

Proceedings of the 19th ACM SIGPLAN International Conference on Functional Programming

Self Cite

View full text Add to dashboard Cite

Behavioral software contracts are a widely used mechanism for governing the flow of values between components. However, runtime monitoring and enforcement of contracts imposes significant overhead and delays discovery of faulty components to run-time.To overcome these issues, we present soft contract verification, which aims to statically prove either complete or partial contract correctness of components, written in an untyped, higher-order language with first-class contracts. Our approach uses higher-order symbolic execution, leveraging contracts as a source of symbolic values including unknown behavioral values, and employs an updatable heap of contract invariants to reason about flow-sensitive facts. We prove the symbolic execution soundly approximates the dynamic semantics and that verified programs can't be blamed.The approach is able to analyze first-class contracts, recursive data structures, unknown functions, and control-flow-sensitive refinements of values, which are all idiomatic in dynamic languages. It makes effective use of an off-the-shelf solver to decide problems without heavy encodings. The approach is competitive with a wide range of existing tools-including type systems, flow analyzers, and model checkers-on their own benchmarks. Contracts (Meyer 1991;Findler and Felleisen 2002) have become a prominent mechanism for specifying and enforcing invariants in dynamic languages (Disney 2013;Plosch 1997;Austin et al. 2011;Strickland et al. 2012;Hickey et al. 2013). They offer the expressivity and flexibility of programming in a dynamic language, while still giving strong guarantees about the interaction of components. However, there are two downsides: (1) contract monitoring is expensive, often prohibitively so, which causes programmers to write more lax specifications, compromising correctness for efficiency; and (2) contract violations are found only at run-time, which delays discovery of faulty components with the usual negative engineering consequences. Categories and Subject Descriptors Static verification for dynamic languagesPermission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from permissions@acm.org. ICFP '14, September 1-6, 2014, Gothenburg, Sweden. Copyright is held by the owner/author(s). Publication rights licensed to ACM. ACM 978-1-4503-2873-9/14/09. . . $15.00. http://dx.doi.org/10. 1145/2628136.2628156 Static verification of contracts would empower programmers to state stronger properties, get immediate feedback on the correctness of their software, and avoid worries abou...

show abstract

Languages as libraries

Cited by 105 publications

References 30 publications

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

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

AnyDSL: a partial evaluation framework for programming high-performance libraries

Soft contract verification

Contact Info

Product

Resources

About