publications: - title: "Code specialization for memory efficient hash tries (short paper)" author: - name: "Michael J. Steindorfer" link: "http://michael.steindorfer.name" - name: "Jurgen J. Vinju" link: "http://homepages.cwi.nl/~jurgenv/" year: "2014" doi: "http://doi.acm.org/10.1145/2658761.2658763" links: doi: "http://doi.acm.org/10.1145/2658761.2658763" dblp: "http://dblp.uni-trier.de/rec/bibtex/conf/gpce/SteindorferV14" researchr: "https://researchr.org/publication/SteindorferV14" cites: 0 citedby: 0 pages: "11-14" booktitle: "GPCE" kind: "inproceedings" key: "SteindorferV14" - title: "PIE: A Domain-Specific Language for Interactive Software Development Pipelines" author: - name: "Gabriël Konat" link: "http://nl.linkedin.com/in/gabrielkonat" - name: "Michael J. Steindorfer" link: "http://michael.steindorfer.name" - name: "Sebastian Erdweg" link: "http://www.informatik.uni-marburg.de/~seba/" - name: "Eelco Visser" link: "http://eelcovisser.org" year: "2018" doi: "https://doi.org/10.22152/programming-journal.org/2018/2/9" abstract: "Context. Software development pipelines are used for automating essential parts of software engineering processes, such as build automation and continuous integration testing. In particular, interactive pipelines, which process events in a live environment such as an IDE, require timely results for low-latency feedback, and persistence to retain low-latency feedback between restarts. Inquiry. Developing an incrementalized and persistent version of a pipeline is one way to reduce feedback latency, but requires implementation of dependency tracking, cache invalidation, and other complicated and error-prone techniques. Therefore, interactivity complicates pipeline development if timeliness and persistence become responsibilities of the pipeline programmer, rather than being supported by the underlying system. Systems for programming incremental and persistent pipelines exist, but do not focus on ease of development, requiring a high degree of boilerplate, increasing development and maintenance effort. Approach. We develop Pipelines for Interactive Environments (PIE), a Domain-Specific Language (DSL), API, and runtime for developing interactive software development pipelines, where ease of development is a focus. The PIE DSL is a statically typed and lexically scoped language. PIE programs are compiled to programs implementing the API, which the PIE runtime executes in an incremental and persistent way. Knowledge. PIE provides a straightforward programming model that enables direct and concise expression of pipelines without boilerplate, reducing the development and maintenance effort of pipelines. Compiled pipeline programs can be embedded into interactive environments such as code editors and IDEs, enabling timely feedback at a low cost. Grounding. Compared to the state of the art, PIE reduces the code required to express an interactive pipeline by a factor of 6 in a case study on syntax-aware editors. Furthermore, we evaluate PIE in two case studies of complex interactive software development scenarios, demonstrating that PIE can handle complex interactive pipelines in a straightforward and concise way. Importance. Interactive pipelines are complicated software artifacts that power many important systems such as continuous feedback cycles in IDEs and code editors, and live language development in language workbenches. New pipelines, and evolution of existing pipelines, is frequently necessary. Therefore, a system for easily developing and maintaining interactive pipelines, such as PIE, is important." links: doi: "https://doi.org/10.22152/programming-journal.org/2018/2/9" dblp: "http://dblp.uni-trier.de/rec/bibtex/journals/programming/KonatSEV18" researchr: "https://researchr.org/publication/KonatSEV18" cites: 0 citedby: 0 journal: "Programming" volume: "2" number: "3" pages: "9" kind: "article" key: "KonatSEV18" - title: "Performance Modeling of Maximal Sharing" author: - name: "Michael J. Steindorfer" link: "http://michael.steindorfer.name" - name: "Jurgen J. Vinju" link: "http://homepages.cwi.nl/~jurgenv/" year: "2016" doi: "http://doi.acm.org/10.1145/2851553.2851566" links: doi: "http://doi.acm.org/10.1145/2851553.2851566" dblp: "http://dblp.uni-trier.de/rec/bibtex/conf/wosp/SteindorferV16" researchr: "https://researchr.org/publication/SteindorferV16" cites: 0 citedby: 0 pages: "135-146" booktitle: "wosp" kind: "inproceedings" key: "SteindorferV16" - title: "Towards a software product line of trie-based collections" author: - name: "Michael J. Steindorfer" link: "http://michael.steindorfer.name" - name: "Jurgen J. Vinju" link: "http://homepages.cwi.nl/~jurgenv/" year: "2016" doi: "http://doi.acm.org/10.1145/2993236.2993251" links: doi: "http://doi.acm.org/10.1145/2993236.2993251" dblp: "http://dblp.uni-trier.de/rec/bibtex/conf/gpce/SteindorferV16" researchr: "https://researchr.org/publication/SteindorferV16-0" cites: 0 citedby: 0 pages: "168-172" booktitle: "GPCE" kind: "inproceedings" key: "SteindorferV16-0" - title: "M3: A general model for code analytics in rascal" author: - name: "Bas Basten" link: "https://researchr.org/alias/bas-basten" - name: "Mark Hills 0001" link: "https://researchr.org/alias/mark-hills-0001" - name: "Paul Klint" link: "http://homepages.cwi.nl/~paulk/" - name: "Davy Landman" link: "https://researchr.org/alias/davy-landman" - name: "Ashim Shahi" link: "https://researchr.org/alias/ashim-shahi" - name: "Michael J. Steindorfer" link: "http://michael.steindorfer.name" - name: "Jurgen J. Vinju" link: "http://homepages.cwi.nl/~jurgenv/" year: "2015" doi: "http://dx.doi.org/10.1109/SWAN.2015.7070485" links: doi: "http://dx.doi.org/10.1109/SWAN.2015.7070485" dblp: "http://dblp.uni-trier.de/rec/bibtex/conf/wcre/Basten0KLSSV15" researchr: "https://researchr.org/publication/Basten0KLSSV15" cites: 0 citedby: 0 pages: "25-28" booktitle: "WCRE" kind: "inproceedings" key: "Basten0KLSSV15" - title: "To-many or to-one? all-in-one! efficient purely functional multi-maps with type-heterogeneous hash-tries" author: - name: "Michael J. Steindorfer" link: "http://michael.steindorfer.name" - name: "Jurgen J. Vinju" link: "http://homepages.cwi.nl/~jurgenv/" year: "2018" doi: "http://doi.acm.org/10.1145/3192366.3192420" links: doi: "http://doi.acm.org/10.1145/3192366.3192420" dblp: "http://dblp.uni-trier.de/rec/bibtex/conf/pldi/SteindorferV18" researchr: "https://researchr.org/publication/SteindorferV18" cites: 0 citedby: 0 pages: "283-295" booktitle: "PLDI" kind: "inproceedings" key: "SteindorferV18" - title: "Optimizing hash-array mapped tries for fast and lean immutable JVM collections" author: - name: "Michael J. Steindorfer" link: "http://michael.steindorfer.name" - name: "Jurgen J. Vinju" link: "http://homepages.cwi.nl/~jurgenv/" year: "2015" doi: "http://doi.acm.org/10.1145/2814270.2814312" links: doi: "http://doi.acm.org/10.1145/2814270.2814312" dblp: "http://dblp.uni-trier.de/rec/bibtex/conf/oopsla/SteindorferV15" researchr: "https://researchr.org/publication/SteindorferV15" cites: 0 citedby: 0 pages: "783-800" booktitle: "OOPSLA" kind: "inproceedings" key: "SteindorferV15" - title: "Towards Zero-Overhead Disambiguation of Deep Priority Conflicts" author: - name: "Luis Eduardo de Souza Amorim" link: "https://www.linkedin.com/profile/view?id=136481548" - name: "Michael J. Steindorfer" link: "http://michael.steindorfer.name" - name: "Eelco Visser" link: "http://eelcovisser.org" year: "2018" doi: "https://doi.org/10.22152/programming-journal.org/2018/2/13" abstract: "Context Context-free grammars are widely used for language prototyping and implementation. They allow formalizing the syntax of domain-specific or general-purpose programming languages concisely and declaratively. However, the natural and concise way of writing a context-free grammar is often ambiguous. Therefore, grammar formalisms support extensions in the form of declarative disambiguation rules to specify operator precedence and associativity, solving ambiguities that are caused by the subset of the grammar that corresponds to expressions. Inquiry Implementing support for declarative disambiguation within a parser typically comes with one or more of the following limitations in practice: a lack of parsing performance, or a lack of modularity (i.e., disallowing the composition of grammar fragments of potentially different languages). The latter subject is generally addressed by scannerless generalized parsers. We aim to equip scannerless generalized parsers with novel disambiguation methods that are inherently performant, without compromising the concerns of modularity and language composition. Approach In this paper, we present a novel low-overhead implementation technique for disambiguating deep associativity and priority conflicts in scannerless generalized parsers with lightweight data-dependency. Knowledge Ambiguities with respect to operator precedence and associativity arise from combining the various operators of a language. While shallow conflicts can be resolved efficiently by one-level tree patterns, deep conflicts require more elaborate techniques, because they can occur arbitrarily nested in a tree. Current state-of-the-art approaches to solving deep priority conflicts come with a severe performance overhead. Grounding We evaluated our new approach against state-of-the-art declarative disambiguation mechanisms. By parsing a corpus of popular open-source repositories written in Java and OCaml, we found that our approach yields speedups of up to 1.73x over a grammar rewriting technique when parsing programs with deep priority conflicts—with a modest overhead of 1–2 % when parsing programs without deep conflicts. Importance A recent empirical study shows that deep priority conflicts are indeed wide-spread in real-world programs. The study shows that in a corpus of popular OCaml projects on Github, up to 17 % of the source files contain deep priority conflicts. However, there is no solution in the literature that addresses efficient disambiguation of deep priority conflicts, with support for modular and composable syntax definitions." links: doi: "https://doi.org/10.22152/programming-journal.org/2018/2/13" dblp: "http://dblp.uni-trier.de/rec/bibtex/journals/programming/AmorimSV18" "pdf": "https://arxiv.org/pdf/1803.10215v1" researchr: "https://researchr.org/publication/AmorimSV18" cites: 0 citedby: 0 journal: "Programming" volume: "2" number: "3" pages: "13" kind: "article" key: "AmorimSV18" - title: "Declarative specification of indentation rules: a tooling perspective on parsing and pretty-printing layout-sensitive languages" author: - name: "Luis Eduardo de Souza Amorim" link: "https://www.linkedin.com/profile/view?id=136481548" - name: "Michael J. Steindorfer" link: "http://michael.steindorfer.name" - name: "Sebastian Erdweg" link: "http://www.informatik.uni-marburg.de/~seba/" - name: "Eelco Visser" link: "http://eelcovisser.org" year: "2018" doi: "https://doi.org/10.1145/3276604.3276607" abstract: " In layout-sensitive languages, the indentation of an expression or statement can influence how a program is parsed. While some of these languages (e.g., Haskell and Python) have been widely adopted, there is little support for software language engineers in building tools for layout-sensitive languages. As a result, parsers, pretty-printers, program analyses, and refactoring tools often need to be handwritten, which decreases the maintainability and extensibility of these tools. Even state-of-the-art language workbenches have little support for layout-sensitive languages, restricting the development and prototyping of such languages. In this paper, we introduce a novel approach to declarative specification of layout-sensitive languages using layout declarations. Layout declarations are high-level specifications of indentation rules that abstract from low-level technicalities. We show how to derive an efficient layout-sensitive generalized parser and a corresponding pretty-printer automatically from a language specification with layout declarations. We validate our approach in a case-study using a syntax definition for the Haskell programming language, investigating the performance of the generated parser and the correctness of the generated pretty-printer against 22191 Haskell files. " links: doi: "https://doi.org/10.1145/3276604.3276607" dblp: "http://dblp.uni-trier.de/rec/bibtex/conf/sle/AmorimSEV18" researchr: "https://researchr.org/publication/AmorimSEV18" cites: 0 citedby: 0 pages: "3-15" booktitle: "SLE" kind: "inproceedings" key: "AmorimSEV18" - title: "Deep priority conflicts in the wild: a pilot study" author: - name: "Luis Eduardo de Souza Amorim" link: "https://www.linkedin.com/profile/view?id=136481548" - name: "Michael J. Steindorfer" link: "http://michael.steindorfer.name" - name: "Eelco Visser" link: "http://eelcovisser.org" year: "2017" doi: "http://doi.acm.org/10.1145/3136014.3136020" abstract: " Context-free grammars are suitable for formalizing the syntax of programming languages concisely and declaratively. Thus, such grammars are often found in reference manuals of programming languages, and used in language workbenches for language prototyping. However, the natural and concise way of writing a context-free grammar is often ambiguous. Safe and complete declarative disambiguation of operator precedence and associativity conflicts guarantees that all ambiguities arising from combining the operators of the language are resolved. Ambiguities can occur due to shallow conflicts, which can be captured by one-level tree patterns, and deep conflicts, which require more elaborate techniques. Approaches to solve deep priority conflicts include grammar transformations, which may result in large unambiguous grammars, or may require adapted parser technologies to include data-dependency tracking at parse time. In this paper we study deep priority conflicts \"in the wild\". We investigate the efficiency of grammar transformations to solve deep priority conflicts by using a lazy parse table generation technique. On top of lazily-generated parse tables, we define metrics, aiming to answer how often deep priority conflicts occur in real-world programs and to what extent programmers explicitly disambiguate programs themselves. By applying our metrics to a small corpus of popular open-source repositories we found that in OCaml, up to 17% of the source files contain deep priority conflicts. " links: doi: "http://doi.acm.org/10.1145/3136014.3136020" dblp: "http://dblp.uni-trier.de/rec/bibtex/conf/sle/AmorimSV17" researchr: "https://researchr.org/publication/AmorimSV17" cites: 0 citedby: 0 pages: "55-66" booktitle: "SLE" kind: "inproceedings" key: "AmorimSV17"