Most of my PhD work is on this language.
Application and evaluation of our extensible language work.
Chemical engineering interdisciplinary work on generating chemical reaction networks.
Abstract: Many programming tasks are dramatically simpler when an appropriate domain-specific language can be used to accomplish them. These languages offer a variety of potential advantages, including programming at a higher level of abstraction, custom analyses specific to the problem domain, and the ability to generate very efficient code. But they also suffer many disadvantages as a result of their implementation techniques. Fully separate languages (such as YACC, or SQL) are quite flexible, but these are distinct monolithic entities and thus we are unable to draw on the features of several in combination to accomplish a single task. That is, we cannot compose their domain-specific features. "Embedded" DSLs (such as parsing combinators) accomplish something like a different language, but are actually implemented simply as libraries within a flexible host language. This approach allows different libraries to be imported and used together, enabling composition, but it is limited in analysis and translation capabilities by the host language they are embedded within. A promising combination of these two approaches is to allow a host language to be directly extended with new features (syntactic and semantic.) However, while there are plausible ways to attempt to compose language extensions, they can easily fail, making this approach unreliable. Previous methods of assuring reliable composition impose onerous restrictions, such as throwing out entirely the ability to introduce new analysis.
This thesis introduces reliably composable language extensions as a technique for the implementation of DSLs. This technique preserves most of the advantages of both separate and "embedded" DSLs. Unlike many prior approaches to language extension, this technique ensures composition of multiple language extensions will succeed, and preserves strong properties about the behavior of the resulting composed compiler. We define an analysis on language extensions that guarantees the composition of several extensions will be well-defined, and we further define a set of testable properties that ensure the resulting compiler will behave as expected, along with a principle that assigns "blame" for bugs that may ultimately appear as a result of composition. Finally, to concretely compare our approach to our original goals for reliably composable language extension, we use these techniques to develop an extensible C compiler front-end, together with several example composable language extensions.
This is a synthesis of my own and previous work, yielding an extensible C compiler that supports actual reliable composition of language extensions. (While this topic also appears as chapter 7 of my PhD thesis, this paper has significant differences from my thesis, reflecting contributions to AbleC from the co-authors.)
The second central contribution of my PhD thesis. I found a way to write proofs of a certain class of "coherent" properties about language extensions, and preserve these proofs, even when composing with unknown other language extensions. This ensure that extensions will always have their specificed behavior and will not "interfere" with each other. This theory also comes with an enforcement method for testing for violations, without requiring developers to actually do verification. See also, PhD thesis, chapter 6, for an expanded version of this paper.
This is pretty much the central work of my PhD thesis. I found a way to adapt the standard well-definedness analysis of attribute grammars to be enforcable in a modular way, rather than requiring a whole program analysis. A major consequence of this is the ability to freely compose together any extensions that pass this analysis, confident the result will be a well-defined attribute grammar. See also, PhD thesis, chapter 5, for an expanded version of this paper.
This work documents a number of interesting problems, observations and solutions in merging the attribute grammar formalism with functional programming. The biggest contribution is the integration of function programming pattern matching with attribute grammar forwarding. This permits the use of pattern matching without sacrificing any potential for extensibility. See also: PhD thesis, chapter 4, for an expanded version of this paper.
Each item in the section is accompanied by a reason it's not above. Typically, these are papers I was only a coauthor on, or they were not published in a sufficiently strictly peer-reviewed venue, or they were not of significant individual technical contribution.
All academic talks I've given, including any conference publications listed above that I presented.