How to Build Static Checking Systems Using Orders of Magnitude Less Code

Brown, Fraser; Nötzli, Andres; Engler, Dawson

doi:10.1145/2872362.2872364

Cited by 23 publications

(20 citation statements)

References 29 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…One recent work that echoes our own is Brown et al's [6] work using island grammars [27] to write static analyzers for multiple languages. They show that they only need to represent fragments of a language to construct an analyzer.…”

Section: Chapter 6 Related Workmentioning

confidence: 66%

“…Programmers use transformation tools to do everything from small-scale refactoring [15] to modernizing entire legacy applications [1]. Most tools are wedded to one language (or even one compiler), and often require hundreds of thousands of lines of code to implement [6]. Consequently, as developers use hundreds of languages [22], each tool has a limited potential market, and hence very few are built.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Incremental parametric syntax for multi-language transformation

Koppel

Solar-Lezama

2017

Proceedings Companion of the 2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: So

View full text Add to dashboard Cite

We present a new system for building source-to-source transformations that can run on multiple programming languages, based on a new way of representing programs called incremental parametric syntax. We construct incremental parametric syntaxes for C, Java, JavaScript, Lua, and Python, and demonstrate two multi-language program transformations that can run on all of them. Our evaluation shows that (1) once a transformation is written, relatively little work is required to configure it for a new language (2) transformations built this way output readable code which preserve the structure of the original, according to participants in our human study, and (3) despite dealing with many languages, our transformations can still handle language corner-cases, and pass 90% of compiler test suites.Incremental parametric syntax is based on the datatypes à la carte approach for constructing modular syntax, but extends it with the notion of a sort injection, which allows intermixing language-specific and generic components in a type-safe and modular fashion. Instead of translating each language to a common representation, this allows having a family of representations, each specific to a language, but sharing common components. Our system can construct an incremental parametric syntax semi-automatically from a third-party library for that language, with the user only writing code for the portions they wish to translate into generic components. The resulting incremental parametric syntax is isomorphic to the original representation, allowing transformations to be fully information-preserving. The user can begin by only translating a small fragment of a language into generic components, enough to support a few transformations, and incrementally add more. Our experience shows that constructing an incremental parametric syntax for a new language is easy, typically taking less than a day of work, and that multi-language transformations built against incremental parametric syntaxes can be configured for a large number of languages, with only a small amount of work per language.

show abstract

Section: Chapter 6 Related Workmentioning

confidence: 66%

Section: Introductionmentioning

confidence: 99%

Incremental parametric syntax for multi-language transformation

Koppel

Solar-Lezama

2017

Proceedings Companion of the 2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: So

View full text Add to dashboard Cite

show abstract

“…We believe that the micro grammar approach of [4] addresses both of these concerns: it supports flexible, cross-language checkers with very little developer overhead. Checkers in this system are often under fifty lines long, and adapting a checker from one language to another is possible in five to fifty more lines-far fewer than a traditional system requires.…”

Section: Finding Bugsmentioning

confidence: 99%

Short Paper

Brown

2016

Proceedings of the 2016 ACM Workshop on Programming Languages and Analysis for Security

Self Cite

View full text Add to dashboard Cite

In this paper, we analyze security vulnerabilities in the binding layer of browser code, and propose a research agenda to prevent these weaknesses with (1) static bug checkers and (2) new embedded domain specific languages (EDSLs). Browser vulnerabilities may leak browsing data and sometimes allow attackers to completely compromise users' systems. Some of these security holes result from programmers' difficulties with managing multiple tightly-coupled runtime systems-typically JavaScript and C++. In this paper, we survey the vulnerabilities in code that connects C++ and JavaScript, and explain how they result from differences in the two languages' type systems, memory models, and control flow constructs. With this data, we design a research plan for using static checkers to catch bugs in existing binding code and for designing EDSLs that make writing new, bug-free binding code easier.

show abstract

“…Refinement type systems [31], pluggable type systems [7,12,13,45] and gradual type system [64,65] define additional static checks for programs written against an existing semantics. Some of these systems support fragmentary definitions of new analyses [13,45]. typy is different in that its semantics (static and dynamic) is itself programmable.…”

Section: Related Workmentioning

confidence: 99%

Programmable semantic fragments: the design and implementation of typy

Omar

Aldrich

2016

Proceedings of the 2016 ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences

View full text Add to dashboard Cite

This paper introduces typy, a statically typed programming language embedded by reflection into Python. typy features a fragmentary semantics, i.e. it delegates semantic control over each term, drawn from Python's fixed concrete and abstract syntax, to some contextually relevant user-defined semantic fragment. The delegated fragment programmatically 1) typechecks the term (following a bidirectional protocol); and 2) assigns dynamic meaning to the term by computing a translation to Python. We argue that this design is expressive with examples of fragments that express the static and dynamic semantics of 1) functional records; 2) labeled sums (with nested pattern matching a la ML); 3) a variation on JavaScript's prototypal object system; and 4) typed foreign interfaces to Python and OpenCL. These semantic structures are, or would need to be, defined primitively in conventionally structured languages. We further argue that this design is compositionally wellbehaved. It avoids the expression problem and the problems of grammar composition because the syntax is fixed. Moreover, programs are semantically stable under fragment composition (i.e. defining a new fragment will not change the meaning of existing program components.

show abstract

How to Build Static Checking Systems Using Orders of Magnitude Less Code

Cited by 23 publications

References 29 publications

Incremental parametric syntax for multi-language transformation

Incremental parametric syntax for multi-language transformation

Short Paper

Programmable semantic fragments: the design and implementation of typy

Contact Info

Product

Resources

About