Search Results

Documents authored by Tratt, Laurence

Document
Artifact
DOI: 10.4230/DARTS.6.2.17
Don't Panic! Better, Fewer, Syntax Errors for LR Parsers (Artifact)

Authors: Lukas Diekmann and Laurence Tratt

Published in: DARTS, Volume 6, Issue 2, Special Issue of the 34th European Conference on Object-Oriented Programming (ECOOP 2020)

Abstract
This is the artefact accompanying the paper "Don't Panic! Better, Fewer, Syntax Errors for LR Parsers" by Diekmann and Tratt. It focusses on the experiment from that paper, which compares a number of different error recovery algorithms on a large corpus of data, including all the software necessary to reproduce the experiment from the paper.
Cite as

Lukas Diekmann and Laurence Tratt. Don't Panic! Better, Fewer, Syntax Errors for LR Parsers (Artifact). In Special Issue of the 34th European Conference on Object-Oriented Programming (ECOOP 2020). Dagstuhl Artifacts Series (DARTS), Volume 6, Issue 2, pp. 17:1-17:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2020)

Copy BibTex To Clipboard

@Article{diekmann_et_al:DARTS.6.2.17,
  author =	{Diekmann, Lukas and Tratt, Laurence},
  title =	{{Don't Panic! Better, Fewer, Syntax Errors for LR Parsers (Artifact)}},
  pages =	{17:1--17:2},
  journal =	{Dagstuhl Artifacts Series},
  ISSN =	{2509-8195},
  year =	{2020},
  volume =	{6},
  number =	{2},
  editor =	{Diekmann, Lukas and Tratt, Laurence},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DARTS.6.2.17},
  URN =		{urn:nbn:de:0030-drops-132143},
  doi =		{10.4230/DARTS.6.2.17},
  annote =	{Keywords: Parsing, error recovery, programming languages}
}
Document
DOI: 10.4230/LIPIcs.ECOOP.2020.6
Don't Panic! Better, Fewer, Syntax Errors for LR Parsers

Authors: Lukas Diekmann and Laurence Tratt

Published in: LIPIcs, Volume 166, 34th European Conference on Object-Oriented Programming (ECOOP 2020)

Abstract
Syntax errors are generally easy to fix for humans, but not for parsers in general nor LR parsers in particular. Traditional "panic mode" error recovery, though easy to implement and applicable to any grammar, often leads to a cascading chain of errors that drown out the original. More advanced error recovery techniques suffer less from this problem but have seen little practical use because their typical performance was seen as poor, their worst case unbounded, and the repairs they reported arbitrary. In this paper we introduce the CPCT+ algorithm, and an implementation of that algorithm, that address these issues. First, CPCT+ reports the complete set of minimum cost repair sequences for a given location, allowing programmers to select the one that best fits their intention. Second, on a corpus of 200,000 real-world syntactically invalid Java programs, CPCT+ is able to repair 98.37%±0.017% of files within a timeout of 0.5s. Finally, CPCT+ uses the complete set of minimum cost repair sequences to reduce the cascading error problem, where incorrect error recovery causes further spurious syntax errors to be identified. Across the test corpus, CPCT+ reports 435,812±473 error locations to the user, reducing the cascading error problem substantially relative to the 981,628±0 error locations reported by panic mode.
Cite as

Lukas Diekmann and Laurence Tratt. Don't Panic! Better, Fewer, Syntax Errors for LR Parsers. In 34th European Conference on Object-Oriented Programming (ECOOP 2020). Leibniz International Proceedings in Informatics (LIPIcs), Volume 166, pp. 6:1-6:32, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2020)

Copy BibTex To Clipboard

@InProceedings{diekmann_et_al:LIPIcs.ECOOP.2020.6,
  author =	{Diekmann, Lukas and Tratt, Laurence},
  title =	{{Don't Panic! Better, Fewer, Syntax Errors for LR Parsers}},
  booktitle =	{34th European Conference on Object-Oriented Programming (ECOOP 2020)},
  pages =	{6:1--6:32},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-154-2},
  ISSN =	{1868-8969},
  year =	{2020},
  volume =	{166},
  editor =	{Hirschfeld, Robert and Pape, Tobias},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2020.6},
  URN =		{urn:nbn:de:0030-drops-131630},
  doi =		{10.4230/LIPIcs.ECOOP.2020.6},
  annote =	{Keywords: Parsing, error recovery, programming languages}
}
Document
DOI: 10.4230/LIPIcs.ECOOP.2017.5
Modelling Homogeneous Generative Meta-Programming

Authors: Martin Berger, Laurence Tratt, and Christian Urban

Published in: LIPIcs, Volume 74, 31st European Conference on Object-Oriented Programming (ECOOP 2017)

Abstract
Homogeneous generative meta-programming (HGMP) enables the generation of program fragments at compile-time or run-time. We present a foundational calculus which can model both compile-time and run-time evaluated HGMP, allowing us to model, for the first time, languages such as Template Haskell. The calculus is designed such that it can be gradually enhanced with the features needed to model many of the advanced features of real languages. We demonstrate this by showing how a simple, staged type system as found in Template Haskell can be added to the calculus.
Cite as

Martin Berger, Laurence Tratt, and Christian Urban. Modelling Homogeneous Generative Meta-Programming. In 31st European Conference on Object-Oriented Programming (ECOOP 2017). Leibniz International Proceedings in Informatics (LIPIcs), Volume 74, pp. 5:1-5:23, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2017)

Copy BibTex To Clipboard

@InProceedings{berger_et_al:LIPIcs.ECOOP.2017.5,
  author =	{Berger, Martin and Tratt, Laurence and Urban, Christian},
  title =	{{Modelling Homogeneous Generative Meta-Programming}},
  booktitle =	{31st European Conference on Object-Oriented Programming (ECOOP 2017)},
  pages =	{5:1--5:23},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-035-4},
  ISSN =	{1868-8969},
  year =	{2017},
  volume =	{74},
  editor =	{M\"{u}ller, Peter},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2017.5},
  URN =		{urn:nbn:de:0030-drops-72775},
  doi =		{10.4230/LIPIcs.ECOOP.2017.5},
  annote =	{Keywords: Formal Methods, Meta-Programming, Operational Semantics, Types, Quasi-Quotes, Abstract Syntax Trees}
}
Document
DOI: 10.4230/LIPIcs.ECOOP.2016.3
Fine-grained Language Composition: A Case Study

Authors: Edd Barrett, Carl Friedrich Bolz, Lukas Diekmann, and Laurence Tratt

Published in: LIPIcs, Volume 56, 30th European Conference on Object-Oriented Programming (ECOOP 2016)

Abstract
Although run-time language composition is common, it normally takes the form of a crude Foreign Function Interface (FFI). While useful, such compositions tend to be coarse-grained and slow. In this paper we introduce a novel fine-grained syntactic composition of PHP and Python which allows users to embed each language inside the other, including referencing variables across languages. This composition raises novel design and implementation challenges. We show that good solutions can be found to the design challenges; and that the resulting implementation imposes an acceptable performance overhead of, at most, 2.6x.
Cite as

Edd Barrett, Carl Friedrich Bolz, Lukas Diekmann, and Laurence Tratt. Fine-grained Language Composition: A Case Study. In 30th European Conference on Object-Oriented Programming (ECOOP 2016). Leibniz International Proceedings in Informatics (LIPIcs), Volume 56, pp. 3:1-3:27, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)

Copy BibTex To Clipboard

@InProceedings{barrett_et_al:LIPIcs.ECOOP.2016.3,
  author =	{Barrett, Edd and Bolz, Carl Friedrich and Diekmann, Lukas and Tratt, Laurence},
  title =	{{Fine-grained Language Composition: A Case Study}},
  booktitle =	{30th European Conference on Object-Oriented Programming (ECOOP 2016)},
  pages =	{3:1--3:27},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-014-9},
  ISSN =	{1868-8969},
  year =	{2016},
  volume =	{56},
  editor =	{Krishnamurthi, Shriram and Lerner, Benjamin S.},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2016.3},
  URN =		{urn:nbn:de:0030-drops-60975},
  doi =		{10.4230/LIPIcs.ECOOP.2016.3},
  annote =	{Keywords: JIT, tracing, language composition}
}
Document
DOI: 10.4230/LIPIcs.ECOOP.2016.4
Making an Embedded DBMS JIT-friendly

Authors: Carl Friedrich Bolz, Darya Kurilova, and Laurence Tratt

Published in: LIPIcs, Volume 56, 30th European Conference on Object-Oriented Programming (ECOOP 2016)

Abstract
While database management systems (DBMSs) are highly optimized, interactions across the boundary between the programming language (PL) and the DBMS are costly, even for in-process embedded DBMSs. In this paper, we show that programs that interact with the popular embedded DBMS SQLite can be significantly optimized -- by a factor of 3.4 in our benchmarks -- by inlining across the PL / DBMS boundary. We achieved this speed-up by replacing parts of SQLite's C interpreter with RPython code and composing the resulting meta-tracing virtual machine (VM) -- called SQPyte -- with the PyPy VM. SQPyte does not compromise stand-alone SQL performance and is 2.2% faster than SQLite on the widely used TPC-H benchmark suite.
Cite as

Carl Friedrich Bolz, Darya Kurilova, and Laurence Tratt. Making an Embedded DBMS JIT-friendly. In 30th European Conference on Object-Oriented Programming (ECOOP 2016). Leibniz International Proceedings in Informatics (LIPIcs), Volume 56, pp. 4:1-4:24, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)

Copy BibTex To Clipboard

@InProceedings{bolz_et_al:LIPIcs.ECOOP.2016.4,
  author =	{Bolz, Carl Friedrich and Kurilova, Darya and Tratt, Laurence},
  title =	{{Making an Embedded DBMS JIT-friendly}},
  booktitle =	{30th European Conference on Object-Oriented Programming (ECOOP 2016)},
  pages =	{4:1--4:24},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-014-9},
  ISSN =	{1868-8969},
  year =	{2016},
  volume =	{56},
  editor =	{Krishnamurthi, Shriram and Lerner, Benjamin S.},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2016.4},
  URN =		{urn:nbn:de:0030-drops-60986},
  doi =		{10.4230/LIPIcs.ECOOP.2016.4},
  annote =	{Keywords: DBMSs, JIT, performance, tracing}
}
Document
DOI: 10.4230/DARTS.2.1.1
Fine-grained Language Composition: A Case Study (Artifact)

Authors: Edd Barrett, Carl Friedrich Bolz, Lukas Diekmann, and Laurence Tratt

Published in: DARTS, Volume 2, Issue 1, Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016)

Abstract
This artifact is based on: PyHyp, a language composition of PHP and Python using meta-tracing; and Eco, a language composition editor. The provided package is designed to support the experiments, case studies, and demos detailed in the companion paper.
Cite as

Edd Barrett, Carl Friedrich Bolz, Lukas Diekmann, and Laurence Tratt. Fine-grained Language Composition: A Case Study (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 1:1-1:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)

Copy BibTex To Clipboard

@Article{barrett_et_al:DARTS.2.1.1,
  author =	{Barrett, Edd and Bolz, Carl Friedrich and Diekmann, Lukas and Tratt, Laurence},
  title =	{{Fine-grained Language Composition: A Case Study (Artifact)}},
  pages =	{1:1--1:2},
  journal =	{Dagstuhl Artifacts Series},
  ISSN =	{2509-8195},
  year =	{2016},
  volume =	{2},
  number =	{1},
  editor =	{Barrett, Edd and Bolz, Carl Friedrich and Diekmann, Lukas and Tratt, Laurence},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.1},
  URN =		{urn:nbn:de:0030-drops-61223},
  doi =		{10.4230/DARTS.2.1.1},
  annote =	{Keywords: JIT, tracing, language composition}
}
Document
DOI: 10.4230/DARTS.2.1.2
Making an Embedded DBMS JIT-friendly (Artifact)

Authors: Carl Friedrich Bolz, Darya Kurilova, and Laurence Tratt

Published in: DARTS, Volume 2, Issue 1, Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016)

Abstract
This artifact contains: the SQPyte prototype, a JIT for executing SQLite queries; and PyPy-SQPyte, a version of the PyPy Python VM which embeds SQPyte. In addition, a benchmark suite is included, which allows performance comparison against standard SQLite and the Java embedded database H2.
Cite as

Carl Friedrich Bolz, Darya Kurilova, and Laurence Tratt. Making an Embedded DBMS JIT-friendly (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 2:1-2:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)

Copy BibTex To Clipboard

@Article{bolz_et_al:DARTS.2.1.2,
  author =	{Bolz, Carl Friedrich and Kurilova, Darya and Tratt, Laurence},
  title =	{{Making an Embedded DBMS JIT-friendly (Artifact)}},
  pages =	{2:1--2:2},
  journal =	{Dagstuhl Artifacts Series},
  ISSN =	{2509-8195},
  year =	{2016},
  volume =	{2},
  number =	{1},
  editor =	{Bolz, Carl Friedrich and Kurilova, Darya and Tratt, Laurence},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.2},
  URN =		{urn:nbn:de:0030-drops-61233},
  doi =		{10.4230/DARTS.2.1.2},
  annote =	{Keywords: DBMSs, JIT, performance, tracing}
}
Document
DOI: 10.4230/OASIcs.ICCSW.2012.142
Search-Based Ambiguity Detection in Context-Free Grammars

Authors: Naveneetha Vasudevan and Laurence Tratt

Published in: OASIcs, Volume 28, 2012 Imperial College Computing Student Workshop

Abstract
Context Free Grammars (CFGs) can be ambiguous, allowing inputs to be parsed in more than one way, something that is undesirable for uses such as programming languages. However, statically detecting ambiguity is undecidable. Though approximation techniques have had some success in uncovering ambiguity, they can struggle when the ambiguous subset of the grammar is large. In this paper, we describe a simple search-based technique which appears to have a better success rate in such cases.
Cite as

Naveneetha Vasudevan and Laurence Tratt. Search-Based Ambiguity Detection in Context-Free Grammars. In 2012 Imperial College Computing Student Workshop. Open Access Series in Informatics (OASIcs), Volume 28, pp. 142-148, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2012)

Copy BibTex To Clipboard

@InProceedings{vasudevan_et_al:OASIcs.ICCSW.2012.142,
  author =	{Vasudevan, Naveneetha and Tratt, Laurence},
  title =	{{Search-Based Ambiguity Detection in Context-Free Grammars}},
  booktitle =	{2012 Imperial College Computing Student Workshop},
  pages =	{142--148},
  series =	{Open Access Series in Informatics (OASIcs)},
  ISBN =	{978-3-939897-48-4},
  ISSN =	{2190-6807},
  year =	{2012},
  volume =	{28},
  editor =	{Jones, Andrew V.},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.ICCSW.2012.142},
  URN =		{urn:nbn:de:0030-drops-37788},
  doi =		{10.4230/OASIcs.ICCSW.2012.142},
  annote =	{Keywords: Ambiguity, Parsing}
}
Questions / Remarks / Feedback
X

Feedback for Dagstuhl Publishing


Thanks for your feedback!

Feedback submitted

Could not send message

Please try again later or send an E-mail
© 2023-2024 Schloss Dagstuhl – LZI GmbH Imprint Privacy Contact