Issue
DARTS, Volume 7, Issue 2
Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021)
-
Part of:
Volume:
DARTS, Volume 7 (ECOOP 2021)
Conference: European Conference on Object-Oriented Programming (ECOOP)
Journal: Dagstuhl Artifacts Series (DARTS)
Publication Details
- published at: 2021-07-06
- Publisher: Schloss Dagstuhl – Leibniz-Zentrum für Informatik
- DBLP: db/journals/darts/darts7
Access Numbers
- Detailed Access Statistics available here
-
Total Document Accesses (updated on a weekly basis):
0PDF Downloads
Documents
No documents found matching your filter selection.
Document
Front Matter
Front Matter - ECOOP 2021 Artifacts, Table of Contents, Preface, Artifact Evaluation Committee
Abstract
Front Matter, Table of Contents, Preface, Conference Organization
Cite as
Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 0:i-0:xi, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{halfond_et_al:DARTS.7.2.0,
author = {Halfond, William G. J. and Sti\'{e}venart, Quentin},
title = {{Front Matter - ECOOP 2021 Artifacts, Table of Contents, Preface, Artifact Evaluation Committee}},
pages = {0:i--0:xi},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Halfond, William G. J. and Sti\'{e}venart, Quentin},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.0},
URN = {urn:nbn:de:0030-drops-140243},
doi = {10.4230/DARTS.7.2.0},
annote = {Keywords: Front Matter, Table of Contents, Preface, Conference Organization}
}
Document
Artifact
Scope States (Artifact)
Abstract
Compilers that can type check compilation units in parallel can make more efficient use of multi-core architectures, which are nowadays widespread. Developing parallel type checker implementations is complicated by the need to handle concurrency and synchronization of parallel compilation units. This artifact contains benchmarks and sources for a new framework for implementing hierarchical type checkers that provides implicit parallel execution in the presence of dynamic and mutual dependencies between compilation units. The resulting type checkers can be written without explicit handling of communication or synchronization between different compilation units. We achieve this by providing type checkers with an API for name resolution based on scope graphs, a language-independent formalism that supports a wide range of binding patterns. Our framework is implemented in Java using the actor paradigm. We evaluated our approach by parallelizing the solver for Statix, a meta-language for type checkers based on scope graphs, using our framework. Benchmarks show that the approach results in speedups for the parallel Statix solver of up to 5.0x on 8 cores for real-world code bases.
Cite as
Hendrik van Antwerpen and Eelco Visser. Scope States (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 1:1-1:7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{vanantwerpen_et_al:DARTS.7.2.1,
author = {van Antwerpen, Hendrik and Visser, Eelco},
title = {{Scope States (Artifact)}},
pages = {1:1--1:7},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {van Antwerpen, Hendrik and Visser, Eelco},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.1},
URN = {urn:nbn:de:0030-drops-140259},
doi = {10.4230/DARTS.7.2.1},
annote = {Keywords: type checking, name resolution, parallel algorithms}
}
Document
Artifact
On the Monitorability of Session Types, in Theory and Practice (Artifact)
Abstract
In the paper "On the Monitorability of Session Types, in Theory and Practice" we study the monitorability of message-passing black-box processes against protocol specifications expressed as session types; we formalise a monitor synthesis procedure, prove its correctness, and discuss its implementation - as a tool that synthesises an executable monitor (in the Scala programming language) from a given session type. This artifact contains the aforementioned monitor synthesis tool, called STMonitor; it includes the tool source code, and documentation to reproduce the examples and benchmarks described in the paper.
Cite as
Christian Bartolo Burlò, Adrian Francalanza, and Alceste Scalas. On the Monitorability of Session Types, in Theory and Practice (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 2:1-2:3, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{bartoloburlo_et_al:DARTS.7.2.2,
author = {Bartolo Burl\`{o}, Christian and Francalanza, Adrian and Scalas, Alceste},
title = {{On the Monitorability of Session Types, in Theory and Practice (Artifact)}},
pages = {2:1--2:3},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Bartolo Burl\`{o}, Christian and Francalanza, Adrian and Scalas, Alceste},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.2},
URN = {urn:nbn:de:0030-drops-140267},
doi = {10.4230/DARTS.7.2.2},
annote = {Keywords: Session types, monitorability, monitor correctness, Scala}
}
Document
Artifact
mist: Refinements of Futures Past (Artifact)
Abstract
mist is a tiny language for teaching and experimenting with refinement types, in the style of https://github.com/ucsd-progsys/liquidhaskell. We use it as a platform for experimenting with and as a demonstration of implicit refinement types as presented in the ECOOP21 paper Refinements of Futures Past: Higher-Order Specification with Implicit Refinement Types. We start with the parser and AST we use to teach our undergradute compilers class, and layer upon it a refinement type checker directly translated from the typing rules presented in that paper, which produces constraints that are solved with the liquid-fixpoint horn clause solver.
We present source code and binaries for mist in a container image that includes installations of the competing tools we compare to.
Cite as
Anish Tondwalkar, Matt Kolosick, and Ranjit Jhala. mist: Refinements of Futures Past (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 3:1-3:11, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{tondwalkar_et_al:DARTS.7.2.3,
author = {Tondwalkar, Anish and Kolosick, Matt and Jhala, Ranjit},
title = {{mist: Refinements of Futures Past (Artifact)}},
pages = {3:1--3:11},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Tondwalkar, Anish and Kolosick, Matt and Jhala, Ranjit},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.3},
URN = {urn:nbn:de:0030-drops-140275},
doi = {10.4230/DARTS.7.2.3},
annote = {Keywords: Refinement Types, Implicit Parameters, Verification, Dependent Pairs}
}
Document
Artifact
Covariant Conversions (CoCo): A Design Pattern for Type-Safe Modular Software Evolution in Object-Oriented Systems (Artifact)
Abstract
This artifact contains code illustrating the Covariant Conversions (CoCo) design pattern in Java, Scala, and C#. The CoCo pattern shows how to solve the expression problem in modern object-oriented languages without the need for language extensions. It structures code so that adding new classes and new methods is possible without changes to existing implementations. The artifact is a live image of a Linux machine for archival purposes. It allows to boot into an environment which has an IDE installed to inspect the code. Build infrastructure to compile, run, test, and benchmark the code without internet access is also included.
Cite as
Jan Bessai, George T. Heineman, and Boris Düdder. Covariant Conversions (CoCo): A Design Pattern for Type-Safe Modular Software Evolution in Object-Oriented Systems (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 4:1-4:4, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{bessai_et_al:DARTS.7.2.4,
author = {Bessai, Jan and Heineman, George T. and D\"{u}dder, Boris},
title = {{Covariant Conversions (CoCo): A Design Pattern for Type-Safe Modular Software Evolution in Object-Oriented Systems (Artifact)}},
pages = {4:1--4:4},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Bessai, Jan and Heineman, George T. and D\"{u}dder, Boris},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.4},
URN = {urn:nbn:de:0030-drops-140287},
doi = {10.4230/DARTS.7.2.4},
annote = {Keywords: Expression problem, software evolution, type safety, producer method, binary method}
}
Document
Artifact
Enabling Additional Parallelism in Asynchronous JavaScript Applications (Artifact)
Abstract
JavaScript is a single-threaded programming language, so asynchronous programming is practiced out of necessity to ensure that applications remain responsive in the presence of user input or interactions with file systems and networks. However, many JavaScript applications execute in environments that do exhibit concurrency by, e.g., interacting with multiple or concurrent servers, or by using file systems managed by operating systems that support concurrent I/O. In this paper, we demonstrate that JavaScript programmers often schedule asynchronous I/O operations suboptimally, and that reordering such operations may yield significant performance benefits. Concretely, we define a static side-effect analysis that can be used to determine how asynchronous I/O operations can be refactored so that asynchronous I/O-related requests are made as early as possible, and so that the results of these requests are awaited as late as possible. While our static analysis is potentially unsound, we have not encountered any situations where it suggested reorderings that change program behavior. We evaluate the refactoring on 20 applications that perform file- or network-related I/O. For these applications, we observe average speedups ranging between 0.99% and 53.6% for the tests that execute refactored code (8.1% on average).
Cite as
Ellen Arteca, Frank Tip, and Max Schäfer. Enabling Additional Parallelism in Asynchronous JavaScript Applications (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 5:1-5:6, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{arteca_et_al:DARTS.7.2.5,
author = {Arteca, Ellen and Tip, Frank and Sch\"{a}fer, Max},
title = {{Enabling Additional Parallelism in Asynchronous JavaScript Applications (Artifact)}},
pages = {5:1--5:6},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Arteca, Ellen and Tip, Frank and Sch\"{a}fer, Max},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.5},
URN = {urn:nbn:de:0030-drops-140290},
doi = {10.4230/DARTS.7.2.5},
annote = {Keywords: asynchronous programming, refactoring, side-effect analysis, performance optimization, static analysis, JavaScript}
}
Document
Artifact
Lifted Static Analysis of Dynamic Program Families by Abstract Interpretation (Artifact)
Abstract
In this article, we describe the usage and evaluation results of the tool DSPLNum²Analyzer introduced by the paper "Lifted Static Analysis of Dynamic Program Families by Abstract Interpretation". We provide step-by-step instructions on how to download, install, run, and compare the tool’s outputs to outputs described in the paper. DSPLNum²Analyzer is a research prototype lifted static analyzer based on abstract interpretation designed for performing numerical static analysis of dynamic C program families.
Cite as
Aleksandar S. Dimovski and Sven Apel. Lifted Static Analysis of Dynamic Program Families by Abstract Interpretation (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 6:1-6:6, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{dimovski_et_al:DARTS.7.2.6,
author = {Dimovski, Aleksandar S. and Apel, Sven},
title = {{Lifted Static Analysis of Dynamic Program Families by Abstract Interpretation (Artifact)}},
pages = {6:1--6:6},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Dimovski, Aleksandar S. and Apel, Sven},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.6},
URN = {urn:nbn:de:0030-drops-140303},
doi = {10.4230/DARTS.7.2.6},
annote = {Keywords: Dynamic program families, Static analysis, Abstract interpretation, Decision tree lifted domain}
}
Document
Artifact
Differential Privacy for Coverage Analysis of Software Traces (Artifact)
Abstract
We propose a differentially private coverage analysis for software traces. To demonstrate that it achieves low error and high precision while preserving privacy, we evaluate the analysis on simulated traces for 15 Android apps. The open source implementation of the analysis, which is in Java, and the dataset used in the experiments are released as an artifact. We also provide specific guidance on reproducing the experimental results.
Cite as
Yu Hao, Sufian Latif, Hailong Zhang, Raef Bassily, and Atanas Rountev. Differential Privacy for Coverage Analysis of Software Traces (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 7:1-7:3, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{hao_et_al:DARTS.7.2.7,
author = {Hao, Yu and Latif, Sufian and Zhang, Hailong and Bassily, Raef and Rountev, Atanas},
title = {{Differential Privacy for Coverage Analysis of Software Traces (Artifact)}},
pages = {7:1--7:3},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Hao, Yu and Latif, Sufian and Zhang, Hailong and Bassily, Raef and Rountev, Atanas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.7},
URN = {urn:nbn:de:0030-drops-140319},
doi = {10.4230/DARTS.7.2.7},
annote = {Keywords: Trace Profiling, Differential Privacy, Program Analysis}
}
Document
Artifact
Multiparty Session Types for Safe Runtime Adaptation in an Actor Language (Artifact)
Abstract
This is the companion artifact for the paper "Multiparty Session Types for Safe Runtime Adaptation in an Actor Language". EnsembleS is an actor-based programming language supporting dynamic self-adaptation, (discovery, replacement, and communication), which also guarantees communication safety. The artifact includes the EnsembleS compiler, the modified StMungo code, and all examples contained within the paper.
Cite as
Paul Harvey, Simon Fowler, Ornela Dardha, and Simon J. Gay. Multiparty Session Types for Safe Runtime Adaptation in an Actor Language (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 8:1-8:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{harvey_et_al:DARTS.7.2.8,
author = {Harvey, Paul and Fowler, Simon and Dardha, Ornela and Gay, Simon J.},
title = {{Multiparty Session Types for Safe Runtime Adaptation in an Actor Language (Artifact)}},
pages = {8:1--8:2},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Harvey, Paul and Fowler, Simon and Dardha, Ornela and Gay, Simon J.},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.8},
URN = {urn:nbn:de:0030-drops-140327},
doi = {10.4230/DARTS.7.2.8},
annote = {Keywords: Concurrency, session types, adaptation, actors, trust}
}
Document
Artifact
Type-Directed Operational Semantics for Gradual Typing (Artifact)
Abstract
This artifact includes the Coq formalization associated with the paper Type-Directed Operational Semantics for Gradual Typing submitted in ECOOP 2021. The paper illustrates how to employ TDOS on gradually typed languages using two calculi. The first calculus, called λB, is inspired by the semantics of the blame calculus(λB^g) and is sound with λB^g. The second calculus, called λB^r, explores a different design space in the semantics of gradually typed languages. This document explains how to run the Coq formalization. Artifact can either be compiled in the pre-built docker image with all the dependencies installed or it could be built from the scratch. Sections 1-7 explain the basic information about the artifact. Section 7 explains how to get the docker image for the artifact. Section 8 explains the prerequisites and the steps to run coq files from scratch. Section 9 explains coq files briefly. Section 10 shows the correspondence of important lemmas, definitions and pictures discussed in the paper with their respective Coq formalization.
Cite as
Wenjia Ye, Bruno C. d. S. Oliveira, and Xuejing Huang. Type-Directed Operational Semantics for Gradual Typing (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 9:1-9:6, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{ye_et_al:DARTS.7.2.9,
author = {Ye, Wenjia and Oliveira, Bruno C. d. S. and Huang, Xuejing},
title = {{Type-Directed Operational Semantics for Gradual Typing (Artifact)}},
pages = {9:1--9:6},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Ye, Wenjia and Oliveira, Bruno C. d. S. and Huang, Xuejing},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.9},
URN = {urn:nbn:de:0030-drops-140337},
doi = {10.4230/DARTS.7.2.9},
annote = {Keywords: Gradual Typing, Operational Semantics, Type Systems}
}
Document
Artifact
Idris 2: Quantitative Type Theory in Practice (Artifact)
Abstract
Dependent types allow us to express precisely what a function is intended to do. Recent work on Quantitative Type Theory (QTT) extends dependent type systems with linearity, also allowing precision in expressing when a function can run. This is promising, because it suggests the ability to design and reason about resource usage protocols, such as we might find in distributed and concurrent programming, where the state of a communication channel changes throughout program execution.
Idris 2 is a new version of Idris, implemented in itself, and based on Quantitative Type Theory. The paper introduces Idris 2 and describes how QTT has influenced its design, as well as giving several examples of how to use QTT in practice. The artifact, correspondingly, provides an implementation of Idris 2, running on a virtual machine, along with runnable examples from the paper. This document explains how to install the artifact, how to run the examples, and suggests some small ways to experiment with and modify the examples.
Cite as
Edwin Brady. Idris 2: Quantitative Type Theory in Practice (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 10:1-10:7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{brady:DARTS.7.2.10,
author = {Brady, Edwin},
title = {{Idris 2: Quantitative Type Theory in Practice (Artifact)}},
pages = {10:1--10:7},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Brady, Edwin},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.10},
URN = {urn:nbn:de:0030-drops-140342},
doi = {10.4230/DARTS.7.2.10},
annote = {Keywords: Dependent types, linear types, concurrency}
}
Document
Artifact
Compositional Programming (Artifact)
Abstract
Our main paper presents CP, a Compositional Programming language in a statically typed modular programming style. This artifact includes its Haskell implementation, together with several examples and three case studies written in CP. All code snippets in our main paper can be type-checked and run using our CP interpreter.
Cite as
Weixin Zhang, Yaozhu Sun, and Bruno C. d. S. Oliveira. Compositional Programming (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 11:1-11:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{zhang_et_al:DARTS.7.2.11,
author = {Zhang, Weixin and Sun, Yaozhu and Oliveira, Bruno C. d. S.},
title = {{Compositional Programming (Artifact)}},
pages = {11:1--11:2},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Zhang, Weixin and Sun, Yaozhu and Oliveira, Bruno C. d. S.},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.11},
URN = {urn:nbn:de:0030-drops-140356},
doi = {10.4230/DARTS.7.2.11},
annote = {Keywords: Expression Problem, Compositionality, Traits}
}
Document
Artifact
Accelerating Object-Sensitive Pointer Analysis by Exploiting Object Containment and Reachability (Artifact)
Abstract
Object-sensitive pointer analysis for an object-oriented program can be accelerated if context-sensitivity can be selectively applied to some precision-critical variables/objects in the program. Existing pre-analyses, which are performed to make such selections, either preserve precision but achieve limited speedups by reasoning about all the possible value flows in the program conservatively or achieve greater speedups but sacrifice precision (often unduly) by examining only some but not all the value flows in the program heuristically. In this paper, we introduce a new approach, named Turner, that represents a sweet spot between the two existing ones, as it is designed to enable object-sensitive pointer analysis to run significantly faster than the former approach and achieve significantly better precision than the latter approach. Turner is simple, lightweight yet effective due to two novel aspects in its design. First, we exploit a key observation that some precision-uncritical objects can be approximated based on the object-containment relationship pre-established (by applying Andersen’s analysis). This approximation introduces a small degree yet the only source of imprecision into Turner. Second, leveraging this initial approximation, we introduce a simple DFA to reason about object reachability for a method intra-procedurally from its entry to its exit along all the possible value flows established by its statements to finalize its precision-critical variables/objects identified. We have validated Turner with an implementation in Soot against the state of the art using a set of 12 popular Java benchmarks and applications.
Cite as
Dongjie He, Jingbo Lu, Yaoqing Gao, and Jingling Xue. Accelerating Object-Sensitive Pointer Analysis by Exploiting Object Containment and Reachability (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 12:1-12:3, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{he_et_al:DARTS.7.2.12,
author = {He, Dongjie and Lu, Jingbo and Gao, Yaoqing and Xue, Jingling},
title = {{Accelerating Object-Sensitive Pointer Analysis by Exploiting Object Containment and Reachability (Artifact)}},
pages = {12:1--12:3},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {He, Dongjie and Lu, Jingbo and Gao, Yaoqing and Xue, Jingling},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.12},
URN = {urn:nbn:de:0030-drops-140363},
doi = {10.4230/DARTS.7.2.12},
annote = {Keywords: Object-Sensitive Pointer Analysis, CFL Reachability, Object Containment}
}
Document
Artifact
CodeDJ: Reproducible Queries over Large-Scale Software Repositories (Artifact)
Abstract
Analyzing massive code bases is a staple of modern software engineering research – a welcome side-effect of the advent of large-scale software repositories such as GitHub. Selecting which projects one should analyze is a labor-intensive process, and a process that can lead to biased results if the selection is not representative of the population of interest. One issue faced by researchers is that the interface exposed by software repositories only allows the most basic of queries. CodeDJ is an infrastructure for querying repositories composed of a persistent datastore, constantly updated with data acquired from GitHub, and an in-memory database with a Rust query interface. CodeDJ supports reproducibility, historical queries are answered deterministically using past states of the datastore; thus researchers can reproduce published results. To illustrate the benefits of CodeDJ, we identify biases in the data of a published study and, by repeating the analysis with new data, we demonstrate that the study’s conclusions were sensitive to the choice of projects.
Cite as
Petr Maj, Konrad Siek¹, Alexander Kovalenko, and Jan Vitek. CodeDJ: Reproducible Queries over Large-Scale Software Repositories (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 13:1-13:4, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{maj_et_al:DARTS.7.2.13,
author = {Maj, Petr and Siek¹, Konrad and Kovalenko, Alexander and Vitek, Jan},
title = {{CodeDJ: Reproducible Queries over Large-Scale Software Repositories (Artifact)}},
pages = {13:1--13:4},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Maj, Petr and Siek¹, Konrad and Kovalenko, Alexander and Vitek, Jan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.13},
URN = {urn:nbn:de:0030-drops-140371},
doi = {10.4230/DARTS.7.2.13},
annote = {Keywords: Software, Mining Code Repositories, Source Code Analysis}
}
Document
Artifact
ALPACAS: A Language for Parametric Assessment of Critical Architecture Safety (Artifact)
Abstract
This artifact contains a virtual machine allowing to use ALPACAS, a domain-specific language and algorithms aimed at architecture modeling and safety assessment for critical systems. ALPACAS allows to study the effects of random and systematic faults on complex critical systems and their reliability. The underlying semantic framework of the language is Stochastic Guarded Transition Systems, for which ALPACAS provides a feature-rich declarative modeling language and algorithms for symbolic analysis and Monte-Carlo simulation, allowing to compute safety indicators such as minimal cutsets and reliability. Built as a domain-specific language deeply embedded in Scala 3, ALPACAS offers generic modeling capabilities and type-safety unparalleled in other existing safety assessment frameworks. This improved expressive power allows to address complex system modeling tasks, such as formalizing the architectural design space of a critical function, and exploring it to identify the most reliable variant. The features and algorithms of ALPACAS are illustrated on a case study of a thrust allocation and power dispatch system for an electric vertical takeoff and landing aircraft.
Cite as
Maxime Buyse, Rémi Delmas, and Youssef Hamadi. ALPACAS: A Language for Parametric Assessment of Critical Architecture Safety (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 14:1-14:4, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{buyse_et_al:DARTS.7.2.14,
author = {Buyse, Maxime and Delmas, R\'{e}mi and Hamadi, Youssef},
title = {{ALPACAS: A Language for Parametric Assessment of Critical Architecture Safety (Artifact)}},
pages = {14:1--14:4},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Buyse, Maxime and Delmas, R\'{e}mi and Hamadi, Youssef},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.14},
URN = {urn:nbn:de:0030-drops-140382},
doi = {10.4230/DARTS.7.2.14},
annote = {Keywords: Domain-Specific Language, Deep Embedding, Scala 3, Architecture Modelling, Safety Assessment, Static Analysis, Monte-Carlo Methods}
}
Document
Artifact
Linear Promises: Towards Safer Concurrent Programming (Artifact)
Abstract
We present a compiler for a concurrent programming language, which utilizes linear typing to create a safer promise abstraction. The compiler is implemented in OCaml and produces source-level Java code. We provide example programs to demonstrate use of the language, as well as translations of incorrect JavaScript code from StackOverflow to showcase the ability of our language to catch many classes of bugs. Finally, we provide a minimal runtime environment to allow the execution of compiled programs.
Cite as
Ohad Rau, Caleb Voss, and Vivek Sarkar. Linear Promises: Towards Safer Concurrent Programming (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 15:1-15:3, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
Copy BibTex To Clipboard
@Article{rau_et_al:DARTS.7.2.15,
author = {Rau, Ohad and Voss, Caleb and Sarkar, Vivek},
title = {{Linear Promises: Towards Safer Concurrent Programming (Artifact)}},
pages = {15:1--15:3},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2021},
volume = {7},
number = {2},
editor = {Rau, Ohad and Voss, Caleb and Sarkar, Vivek},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/DARTS.7.2.15},
URN = {urn:nbn:de:0030-drops-140394},
doi = {10.4230/DARTS.7.2.15},
annote = {Keywords: promises, type systems, linear typing, operational semantics, concurrency}
}