EDUCATIONAL PEARL: A Nanopass framework for compiler education

Sarkar, Dipanwita; Waddell, Oscar; Dybvig, R. Kent

doi:10.1017/s0956796805005605

Cited by 16 publications

(18 citation statements)

References 9 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For example, programmers have used macros to extend Scheme with constructs for pattern matching [36], relations in the spirit of Prolog [8,30,18,23], extensible looping constructs [7,29], class systems [27,1,17] and component systems [34,14,5], among others. In addition, programmers have also used macros to handle metaprogramming tasks traditionally implemented outside the language using preprocessors or special compilers: Owens et al [26] have added a parser generator library to Scheme; Sarkar et al [28] have created an infrastructure for expressing nano-compiler passes; and Herman and Meunier [20] have used macros to improve the static analysis of Scheme programs. As a result, implementations of Scheme such as PLT Scheme [13] have a core of a dozen or so syntactic constructs but appear to implement a language the size of Common Lisp [32].…”

mentioning

confidence: 99%

Debugging macros

Culpepper

Felleisen

2007

Proceedings of the 6th International Conference on Generative Programming and Component Engineering

View full text Add to dashboard Cite

Over the past two decades, Scheme macros have evolved into a powerful API for the compiler front-end. Like Lisp macros, their predecessors, Scheme macros expand source programs into a small core language; unlike Lisp systems, Scheme macro expanders preserve many desirable properties, including lexical scope and source location. Using such macros, Scheme programmers now routinely develop the ultimate abstraction: embedded domain-specific programming languages.Unfortunately, Scheme programming environments provide little support for macro development. This lack makes it difficult for programmers to debug their macros and for novices to study the behavior of macros. In response, we have developed a stepping debugger specialized to the concerns of macro expansion. It presents the macro expansion process as a linear rewriting sequence of annotated terms; it graphically illustrates the binding structure of the program as expansion reveals it; and it adapts to the programmer's level of abstraction, hiding details of syntactic forms that the programmer considers built-in.

show abstract

mentioning

confidence: 99%

Debugging macros

Culpepper

Felleisen

2007

Proceedings of the 6th International Conference on Generative Programming and Component Engineering

View full text Add to dashboard Cite

show abstract

“…The Nanopass Framework [23] is a compiler intended for teaching courses on compiler construction. In the framework, each individual transformation is done in a separate pass.…”

Section: Compilers Based On Tree Transformation Passesmentioning

confidence: 99%

Miniphases: compilation using modular and efficient tree transformations

Petrashko

Lhoták

Odersky

2017

Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

Production compilers commonly perform dozens of transformations on an intermediate representation. Running those transformations in separate passes harms performance. One approach to recover performance is to combine transformations by hand in order to reduce number of passes. Such an approach harms modularity, and thus makes it hard to maintain and evolve a compiler over the long term, and makes reasoning about performance harder. This paper describes a methodology that allows a compiler writer to define multiple transformations separately, but fuse them into a single traversal of the intermediate representation when the compiler runs. This approach has been implemented in the Dotty compiler for the Scala language. Our performance evaluation indicates that this approach reduces the running time of tree transformations by 35% and shows that this is due to improved cache friendliness. At the same time, the approach improves total memory consumption by reducing the object tenuring rate by 50%. This approach enables compiler writers to write transformations that are both modular and fast at the same time.

show abstract

“…• Nanopass source-to-source translation [15] to CoffeScript, with subsequent translation to JS, and evaluation via "native" JS runtime.…”

Section: Livecodelang Implementationmentioning

confidence: 99%