Issue
DARTS, Volume 2, Issue 1
Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016)
-
Part of:
Volume:
DARTS, Volume 2 (ECOOP 2016)
Conference: European Conference on Object-Oriented Programming (ECOOP)
Journal: Dagstuhl Artifacts Series (DARTS)
Editors
Publication Details
- published at: 2016-07-14
- Publisher: Schloss Dagstuhl – Leibniz-Zentrum für Informatik
- DBLP: db/journals/darts/darts2
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, Table of Contents, Preface, Artifact Evaluation Committee
Abstract
Front Matter, Table of Contents, Preface, Artifact Evaluation Committee
Cite as
Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 0:i-0:x, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{flatt_et_al:DARTS.2.1.0,
author = {Flatt, Matthew and van der Storm, Tijs},
title = {{Front Matter, Table of Contents, Preface, Artifact Evaluation Committee}},
pages = {0:i--0:x},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Flatt, Matthew and van der Storm, Tijs},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.0},
URN = {urn:nbn:de:0030-drops-61212},
doi = {10.4230/DARTS.2.1.0},
annote = {Keywords: Front Matter, Table of Contents, Preface, Artifact Evaluation Committee}
}
Document
Fine-grained Language Composition: A Case Study (Artifact)
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
Making an Embedded DBMS JIT-friendly (Artifact)
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
C++ const and Immutability: An Empirical Study of Writes-Through-const (Artifact)
Abstract
This artifact is based on ConstSanitizer, a dynamic program analysis tool that detects deep immutability violations through const qualifiers. Our tool instruments any code compiled by clang with the -fsanitizer=const flag. Our implementation includes both instrumentation of LLVM code and a runtime library to support our analysis. The provided package includes our tool and all experiments used in our companion paper. Instructions are also provided.
Cite as
Jon Eyolfson and Patrick Lam. C++ const and Immutability: An Empirical Study of Writes-Through-const (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 3:1-3:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{eyolfson_et_al:DARTS.2.1.3,
author = {Eyolfson, Jon and Lam, Patrick},
title = {{C++ const and Immutability: An Empirical Study of Writes-Through-const (Artifact)}},
pages = {3:1--3:2},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Eyolfson, Jon and Lam, Patrick},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.3},
URN = {urn:nbn:de:0030-drops-61249},
doi = {10.4230/DARTS.2.1.3},
annote = {Keywords: empirical study, dynamic analysis, immutability}
}
Document
LJGS: Gradual Security Types for Object-Oriented Languages (Artifact)
Abstract
JGS-check is the accompanying artifact to "LJGS: Gradual Security Types for Object-Oriented Languages". LJGS is a Java-like language with gradual security typing. It features a constraint based information flow type system that includes a type dynamic and type casts. Dynamically typed fragments are liberally accepted by the type checker and rely on run-time enforcement for security. JGS-check is a type checker for the subset of Java that corresponds to the calculus presented in the paper and that implements the constraint generation and satisfiability checks of LJGS' type system. It's purpose is to illustrate and substantiate the behavior of our gradual security type system. It takes a directory of Java source code as input and reports methods that violate the typing rules. JGS-check is merely a type checker and does not implement code generation.
The submission archive includes the compiled type checker, the code of the example section (Section 2) as well additional examples and testcases that did not fit into the paper. The user should also be able to check custom code as long as it corresponds the subset of Java that is covered by LJGS.
Cite as
Luminous Fennell and Peter Thiemann. LJGS: Gradual Security Types for Object-Oriented Languages (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 4:1-4:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{fennell_et_al:DARTS.2.1.4,
author = {Fennell, Luminous and Thiemann, Peter},
title = {{LJGS: Gradual Security Types for Object-Oriented Languages (Artifact)}},
pages = {4:1--4:2},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Fennell, Luminous and Thiemann, Peter},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.4},
URN = {urn:nbn:de:0030-drops-61253},
doi = {10.4230/DARTS.2.1.4},
annote = {Keywords: gradual typing, security typing, Java, hybrid information flow control}
}
Document
Magic with Dynamo – Flexible Cross-Component Linking for Java with Invokedynamic (Artifact)
Abstract
Modern software systems are not built from scratch. They use functionality provided by libraries. These libraries evolve and often upgrades are deployed without the systems being recompiled.
In Java, this process is particularly error-prone due to the mismatch between source and binary compatibility, and the lack of API stability in many popular libraries. We propose a novel approach to mitigate this problem based on the use of invokedynamic instructions for cross-component method invocations. The dispatch mechanism of invokedynamic is used to provide on-the-fly signature adaptation. We show how this idea can be used to construct a Java compiler that produces more resilient bytecode. We present the dynamo compiler, a proof-of-concept implemented as javac post compiler, and evaluate our approach using several benchmark examples and two case studies showing how the use of the dynamo compiler can prevent certain types of linkage and stack overflow errors that have been observed in real-world systems.
Cite as
Kamil Jezek and Jens Dietrich. Magic with Dynamo – Flexible Cross-Component Linking for Java with Invokedynamic (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 5:1-5:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{jezek_et_al:DARTS.2.1.5,
author = {Jezek, Kamil and Dietrich, Jens},
title = {{Magic with Dynamo – Flexible Cross-Component Linking for Java with Invokedynamic (Artifact)}},
pages = {5:1--5:2},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Jezek, Kamil and Dietrich, Jens},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.5},
URN = {urn:nbn:de:0030-drops-61260},
doi = {10.4230/DARTS.2.1.5},
annote = {Keywords: Java, compilation, linking, binary compatibility, invokedynamic}
}
Document
Object Inheritance Without Classes (Artifact)
Abstract
This artifact is a PLT Redex implementation of the operational semantics presented in Object Inheritance Without Classes. It defines the core syntax and runtime semantics of the Graceless language, and then extends it in multiple different ways to produce the various implementations of object inheritance, including single and multiple inheritance. The implementation makes the semantics runnable, and precisely defines some behaviour which is defined informally in the paper.
Cite as
Timothy Jones and Michael Homer. Object Inheritance Without Classes (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 6:1-6:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{jones_et_al:DARTS.2.1.6,
author = {Jones, Timothy and Homer, Michael},
title = {{Object Inheritance Without Classes (Artifact)}},
pages = {6:1--6:2},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Jones, Timothy and Homer, Michael},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.6},
URN = {urn:nbn:de:0030-drops-61278},
doi = {10.4230/DARTS.2.1.6},
annote = {Keywords: Inheritance, Objects, Classes, Operational semantics, PLT Redex}
}
Document
One Way to Select Many (Artifact)
Abstract
The artifact is built around the MultiselectJS library that implements the multi-selection semantics presented in the companion paper. The purpose of this JavaScript library is to help programmers add multi-selection to Web user interfaces with ease. The artifact includes a demo application showcasing the use of the library, documentation of the library API, and a tutorial on how to use the library. The library clearly separates the reusable aspects of multi-selection from the application specific aspects. The latter are collected into an object referred to as the selection geometry. The complex task of implementing a full-fledged multi-selection feature reduces to a considerably simpler task of implementing a selection geometry. The demo application implements several different selection geometries. It supports the claims of the companion paper that the library considerably lessens the task of implementing multi-selection. Following the guidance of the tutorial, users can build their own multi-selection features.
Cite as
Jaakko Järvi and Sean Parent. One Way to Select Many (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 7:1-7:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{jarvi_et_al:DARTS.2.1.7,
author = {Järvi, Jaakko and Parent, Sean},
title = {{One Way to Select Many (Artifact)}},
pages = {7:1--7:2},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Järvi, Jaakko and Parent, Sean},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.7},
URN = {urn:nbn:de:0030-drops-61280},
doi = {10.4230/DARTS.2.1.7},
annote = {Keywords: User interfaces, Multi-selection, JavaScript}
}
Document
Program Tailoring: Slicing by Sequential Criteria (Artifact)
Abstract
Protocol and typestate analyses often report some sequences of statements ending at a program point P that needs to be scrutinized, since P may be erroneous or imprecisely analyzed. Program slicing focuses only on the behavior at P by computing a slice of the program affecting the values at P. In our companion paper "Program Tailoring: Slicing by Sequential Criteria", we propose to focus on the subset of that behavior at P affected by one or several statement sequences, called a sequential criterion (SC). By leveraging the ordering information in a SC, e.g., the temporal order in a few valid/invalid API method invocation sequences, we introduce a new technique, program tailoring, to compute a tailored program that comprises the statements in all possible execution paths passing through at least one sequence in SC in the given order.
This artifact is based on TAILOR, a prototyping implementation of program tailoring, to evaluate the usefulness of TAILOR in practice. The provided package is designed to support repeatability of all the experiments of our companion paper. Specifically, it allows users to reproduce the results for all the three research questions addressed in the evaluation section of our companion paper. In addition, an extensive set of extra results, which are not described in the companion paper, are also included, in order to help users better understand this work.
Cite as
Tian Tan, Yue Li, Yifei Zhang, and Jingling Xue. Program Tailoring: Slicing by Sequential Criteria (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 8:1-8:3, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{tan_et_al:DARTS.2.1.8,
author = {Tan, Tian and Li, Yue and Zhang, Yifei and Xue, Jingling},
title = {{Program Tailoring: Slicing by Sequential Criteria (Artifact)}},
pages = {8:1--8:3},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Tan, Tian and Li, Yue and Zhang, Yifei and Xue, Jingling},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.8},
URN = {urn:nbn:de:0030-drops-61298},
doi = {10.4230/DARTS.2.1.8},
annote = {Keywords: Program Slicing, Program Analysis, API Protocol Specification}
}
Document
Higher-Order Demand-Driven Program Analysis (Artifact)
Abstract
This artifact is a proof-of-concept implementation of DDPA, an on-demand program analysis for higher-order functional programs. The implementation, written in OCaml, includes a parser, evaluator, and DDPA analysis for the language defined in the companion paper (including the proper record semantics extension). The analysis may be performed using different levels of precision as specified by the user and is capable of rendering the control flow graphs and pushdown systems using the GraphViz language DOT. This artifact was used to verify the conclusions of the companion paper and produces visualizations matching those figures in the companion paper's overview.
Cite as
Leandro Facchinetti, Zachary Palmer, and Scott F. Smith. Higher-Order Demand-Driven Program Analysis (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 9:1-9:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{facchinetti_et_al:DARTS.2.1.9,
author = {Facchinetti, Leandro and Palmer, Zachary and Smith, Scott F.},
title = {{Higher-Order Demand-Driven Program Analysis (Artifact)}},
pages = {9:1--9:2},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Facchinetti, Leandro and Palmer, Zachary and Smith, Scott F.},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.9},
URN = {urn:nbn:de:0030-drops-61304},
doi = {10.4230/DARTS.2.1.9},
annote = {Keywords: program analysis, polynomial, demand-driven, flow-sensitive, context-sensitive}
}
Document
Scopes Describe Frames: A Uniform Model for Memory Layout in Dynamic Semantics (Artifact)
Abstract
Our paper introduces a systematic approach to the alignment of names in the static structure of a program, and memory layout and access during its execution. We develop a uniform memory model consisting of frames that instantiate the scopes in the scope graph of a program. This provides a language-independent correspondence between static scopes and run-time memory layout, and between static resolution paths and run-time memory access paths. The approach scales to a range of binding features, supports straightforward type soundness proofs, and provides the basis for a language-independent specification of sound reachability-based garbage collection.
This Coq artifact showcases how our uniform model for memory layout in dynamic semantics provides structure to type soundness proofs. The artifact contains type soundness proofs mechanized in Coq for (supersets of) all languages in the paper. The type soundness proofs rely on a language-independent framework formalizing scope graphs and frame heaps.
Cite as
Casper Bach Poulsen, Pierre Néron, Andrew Tolmach, and Eelco Visser. Scopes Describe Frames: A Uniform Model for Memory Layout in Dynamic Semantics (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 10:1-10:3, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{bachpoulsen_et_al:DARTS.2.1.10,
author = {Bach Poulsen, Casper and Néron, Pierre and Tolmach, Andrew and Visser, Eelco},
title = {{Scopes Describe Frames: A Uniform Model for Memory Layout in Dynamic Semantics (Artifact)}},
pages = {10:1--10:3},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Bach Poulsen, Casper and Néron, Pierre and Tolmach, Andrew and Visser, Eelco},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.10},
URN = {urn:nbn:de:0030-drops-61314},
doi = {10.4230/DARTS.2.1.10},
annote = {Keywords: Dynamic semantics, scope graphs, memory layout, type soundness, operational semantics}
}
Document
Lightweight Session Programming in Scala (Artifact)
Abstract
In the paper "Lightweight Session Programming in Scala", we introduce a "lightweight" integration of session types in the Scala programming language, based on (1) a formal type-level encoding, and (2) a library implementation of linear I/O channels, called lchannels, providing a convenient API for session-based programming, and supporting both local and distributed communication. This artifact is the source code of lchannels, with all the examples and benchmarks discussed in the paper.
Cite as
Alceste Scalas and Nobuko Yoshida. Lightweight Session Programming in Scala (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 11:1-11:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{scalas_et_al:DARTS.2.1.11,
author = {Scalas, Alceste and Yoshida, Nobuko},
title = {{Lightweight Session Programming in Scala (Artifact)}},
pages = {11:1--11:2},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Scalas, Alceste and Yoshida, Nobuko},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.11},
URN = {urn:nbn:de:0030-drops-61327},
doi = {10.4230/DARTS.2.1.11},
annote = {Keywords: session types, Scala, concurrency}
}
Document
Boomerang: Demand-Driven Flow- and Context-Sensitive Pointer Analysis for Java (Artifact)
Abstract
Evaluating pointer analyses with respect to soundness and precision has been a tedious task. Within this artifact we present PointerBench, the benchmark suite used in the paper to compare the pointer analysis Boomerang with two other demand-driven pointer analyses, SB [Sridharan and Bodik, 2006] and DA [Yan et al., 2011]. We show PointerBench can be used to test different pointer analyses.
In addition to that, the artifact contains usage examples for Boomerang on simple test programs. The test programs and the input on these programs to Boomerang can be changed to experiment with the algorithm and its features.
Additionally, the artifact contains the integration of Boomerang, SB, and DA into FlowDroid, which can then be executed on arbitrary Android applications.
Cite as
Johannes Späth, Lisa Nguyen Quang Do, Karim Ali, and Eric Bodden. Boomerang: Demand-Driven Flow- and Context-Sensitive Pointer Analysis for Java (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 12:1-12:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{spath_et_al:DARTS.2.1.12,
author = {Sp\"{a}th, Johannes and Nguyen Quang Do, Lisa and Ali, Karim and Bodden, Eric},
title = {{Boomerang: Demand-Driven Flow- and Context-Sensitive Pointer Analysis for Java (Artifact)}},
pages = {12:1--12:2},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Sp\"{a}th, Johannes and Nguyen Quang Do, Lisa and Ali, Karim and Bodden, Eric},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.12},
URN = {urn:nbn:de:0030-drops-61334},
doi = {10.4230/DARTS.2.1.12},
annote = {Keywords: Demand-Driven; Static Analysis; IFDS; Aliasing; Points-to Analysis}
}
Document
Transactional Tasks: Parallelism in Software Transactions (Artifact)
Abstract
Many programming languages support different concurrency models. In practice these models are often combined, however the semantics of the combinations are not always well-defined. We studied the combination of futures and Software Transactional Memory. We introduce transactional tasks, a mechanism to create futures in a transaction. Transactional tasks allow the parallelism in a transaction to be exploited, while providing safe access to the state of their encapsulating transaction. We created Clojure-TxTk, a fork of Clojure with support for transactional tasks. Furthermore, we ported two applications from the STAMP benchmark suite, and extended these to use transactional tasks: Labyrinth-TxTk and Bayes-TxTk. Lastly, TxTk-Redex is a machine-executable implementation of the operational semantics, in PLT Redex.
Cite as
Janwillem Swalens. Transactional Tasks: Parallelism in Software Transactions (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 13:1-13:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{swalens:DARTS.2.1.13,
author = {Swalens, Janwillem},
title = {{Transactional Tasks: Parallelism in Software Transactions (Artifact)}},
pages = {13:1--13:2},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Swalens, Janwillem},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.13},
URN = {urn:nbn:de:0030-drops-61348},
doi = {10.4230/DARTS.2.1.13},
annote = {Keywords: Concurrency, Parallelism, Futures, Threads, Fork/Join, Software Transactional Memory}
}
Document
Staccato: A Bug Finder for Dynamic Configuration Updates (Artifact)
Abstract
This artifact is based on Staccato, a tool for finding errors in dynamic configuration update (DCU) implementations. Dynamic configuration update refers to configuration changes that occur at runtime without program restart. Errors in DCU implementations occur when stale data - computed from old configurations - or inconsistent data - computed from different configurations - are used. Staccato uses a dynamic analysis in the style of taint analysis to detect these errors. Staccato supports concurrent programs running on commodity JVMs. We evaluated Staccato on three open-source applications and found errors in all of them.
Cite as
John Toman and Dan Grossman. Staccato: A Bug Finder for Dynamic Configuration Updates (Artifact). In Special Issue of the 30th European Conference on Object-Oriented Programming (ECOOP 2016). Dagstuhl Artifacts Series (DARTS), Volume 2, Issue 1, pp. 14:1-14:2, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)
Copy BibTex To Clipboard
@Article{toman_et_al:DARTS.2.1.14,
author = {Toman, John and Grossman, Dan},
title = {{Staccato: A Bug Finder for Dynamic Configuration Updates (Artifact)}},
pages = {14:1--14:2},
journal = {Dagstuhl Artifacts Series},
ISSN = {2509-8195},
year = {2016},
volume = {2},
number = {1},
editor = {Toman, John and Grossman, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.2.1.14},
URN = {urn:nbn:de:0030-drops-61350},
doi = {10.4230/DARTS.2.1.14},
annote = {Keywords: Dynamic Configuration Updates, Dynamic Analysis, Software configuration}
}