SPLASH Workshop/Symposium Events 2021
2021 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH Events 2021)
Powered by
Conference Publishing Consulting

17th ACM SIGPLAN International Symposium on Dynamic Languages (DLS 2021), October 19, 2021, Chicago, IL, USA

DLS 2021 – Proceedings

Contents - Abstracts - Authors

17th ACM SIGPLAN International Symposium on Dynamic Languages (DLS 2021)


Title Page

Welcome from the Chair
Welcome to the the 17th edition of the Dynamic Language Symposium (DLS), co-located with SPLASH 2021.
DLS is the premier forum for researchers and practitioners to share research results and experience on all aspects on dynamic languages—by which we mean languages like Clojure, Dart, Elixer, Erlang, JavaScript, Julia, Lisp, Lua, Perl, Python, Ruby, R, Racket, Scheme, Smalltalk, and more. As demonstrated again by this year’s program, the inuence of work in these languages extends beyond the implementation and direct use of dynamic languages.

DLS 2021 Organization
Committee Listings


Union and Intersection Contracts Are Hard, Actually
Teodoro Freund, Yann Hamdaoui, and Arnaud Spiwack ORCID logo
(University of Buenos Aires, Argentina; Tweag, France)
Union and intersection types are a staple of gradually typed languages such as TypeScript. While it's long been recognized that union and intersection types are difficult to verify statically, it may appear at first that the dynamic part of gradual typing is actually pretty simple.
It turns out however, that in presence of higher-order contracts union and intersection are deceptively difficult. The literature on higher-order contracts with union and intersection, while keenly aware of the fact, doesn't really explain why. We point and illustrate the problems and trade-offs inherent to union and intersection contracts, via example and a survey of the literature.

Publisher's Version
First-Class Environments in R
Aviral Goel ORCID logo and Jan Vitek ORCID logo
(Northeastern University, USA; Czech Technical University, Czechia)
The R programming language is widely used for statistical computing. To enable interactive data exploration and rapid prototyping, R encourages a dynamic programming style. This programming style is supported by features such as first-class environments. Amongst widely used languages, R has the richest interface for programmatically manipulating environments. With the flexibility afforded by reflective operations on first-class environments, come significant challenges for reasoning and optimizing user-defined code. This paper documents the reflective interface used to operate over first-class environment. We explain the rationale behind its design and conduct a large-scale study of how the interface is used in popular libraries.

Publisher's Version
Analyzing Permission Transfer Channels for Dynamically Typed Languages
Théo Rogliano, Guillermo PolitoORCID logo, Luc Fabresse, and Stéphane DucasseORCID logo
(Inria, France; University of Lille, France; CNRS, France; Centrale Lille, France; CRIStAL, France; IMT Lille Douai, France; Institut Mines-Télécom, France; Centre for Digital Systems, France)
Communicating Sequential Process ‍(CSP) is nowadays a popular concurrency model in which threads/processes communicate by exchanging data through channels. Channels help in orchestrating concurrent processes but do not solve per-se data races. To prevent data races in the channel model, many programming languages rely on type systems to express ownership and behavioural restrictions such as immutability. However, dynamically-typed languages require run-time mechanisms because of the lack of type information at compile-time.
In this paper, we propose to augment channels with four different permission transfer semantics. We explore two mechanisms to implement such permission transfers at run time: write barriers and partial-read barriers. To validate our approach we implemented a channel framework in Pharo, and we extended it with different permission transfer semantics. We report on performance measurements of both (a) the transfer overhead on a single object and on a graph of objects, and (b) the per-object access overhead incurred by ownership checks. This work stands as a cornerstone of future work on adaptive optimizations for permission transfer channels.

Publisher's Version
CompGen: Generation of Fast JIT Compilers in a Multi-language VM
Florian Latifi, David LeopoldsederORCID logo, Christian Wimmer ORCID logo, and Hanspeter MössenböckORCID logo
(JKU Linz, Austria; Oracle Labs, Austria; Oracle Labs, USA)
The first Futamura projection enables compilation and high performance code generation of user programs by partial evaluation of language interpreters. Previous work has shown that online partial evaluation can yield the same peak performance as a specialized JIT compiler. However, this comes with the downside of additional compile time: Online partial evaluation of language interpreters has to specialize interpreter code on the fly to the dynamic types used at run time to create efficient target code. As a result, the time spent on partial evaluation itself is a significant contributor to the overall compile time of a method.
The second Futamura projection solves this problem by self-applying partial evaluation on the partial evaluation algorithm, effectively generating language-specific compilers from interpreters. This typically reduces compilation time compared to the first projection. Previous work employed the second projection to some extent, however we are not aware of any usage of the generic second Futamura projection in a state-of-the-art language runtime.
To solve the problems of self-application and code-size explosion, this paper proposes CompGen, an approach based on code generation of subsets of language interpreters. It is loosely based upon the idea of the second Futamura projection. Our implementation of CompGen for GraalVM shows that our usage of a novel code-generation algorithm allows us to generate efficient compilers that emit fast target programs which easily outperform the first Futamura projection in compilation time. We evaluated our approach with the high-performance JavaScript implementation of GraalVM and standard JavaScript benchmarks, showing that our approach achieves >2X speedups of partial evaluation.

Publisher's Version
Runtime and Compiler Support for HAMTs
Sona Torosyan, Jon Zeppieri, and Matthew Flatt ORCID logo
(University of Utah, USA)
Many functional languages---including Racket, Clojure, and Scala---provide a persistent-map datatype with an implementation based on Hash Array Mapped Tries (HAMTs). HAMTs enable efficient functional lookup, insertion, and deletion operations with a small memory footprint, especially when taking advantage of implementation techniques that have been developed since the original HAMT implementation. Racket's latest HAMT implementation is based on an intermediate data structure, a stencil vector, that supports an especially compact representation of HAMTs with help from the compiler and memory manager. That is, stencil vectors provide an abstraction to improve HAMT performance without burdening the compiler with all of the complexity and design choices of a HAMT implementation. Benchmark measurements show that HAMTs in Racket have performance comparable to other state-of-the-art implementations, while stencil-vector HAMTs are more compact and run as fast as alternative representations in Racket. Although we only report on Racket, our experience suggests that a stencil-vector datatype in other dynamic-language implementations might improve HAMT performance in those implementations.

Publisher's Version

proc time: 1.85