Programming Languages (PACMPL)


Search Issue
enter search term and/or author name


Proceedings of the ACM on Programming Languages, Volume 1 Issue OOPSLA, October 2017

Here is the link to the page in the digital library for this issue. The digital library may contain some content that is not included in this table of contents, for example front and back matter for the issue.

Section: Types

SAVI objects: sharing and virtuality incorporated
Izzat El Hajj, Thomas B. Jablin, Dejan Milojicic, Wen-mei Hwu
Article No.: 45
DOI: 10.1145/3133869

Direct sharing and storing of memory objects allows high-performance and low-overhead collaboration between parallel processes or application workflows with loosely coupled programs. However, sharing of objects is hindered by the inability to use ...

A simple soundness proof for dependent object types
Marianna Rapoport, Ifaz Kabir, Paul He, Ondřej Lhoták
Article No.: 46
DOI: 10.1145/3133870

Dependent Object Types (DOT) is intended to be a core calculus for modelling Scala. Its distinguishing feature is abstract type members, fields in objects that hold types rather than values. Proving soundness of DOT has been surprisingly ...

Unifying typing and subtyping
Yanpeng Yang, Bruno C. d. S. Oliveira
Article No.: 47
DOI: 10.1145/3133871

In recent years dependent types have become a hot topic in programming language research. A key reason why dependent types are interesting is that they allow unifying types and terms, which enables both additional expressiveness and ...

Fast and precise type checking for JavaScript
Avik Chaudhuri, Panagiotis Vekris, Sam Goldman, Marshall Roch, Gabriel Levi
Article No.: 48
DOI: 10.1145/3133872

In this paper we present the design and implementation of Flow, a fast and precise type checker for JavaScript that is used by thousands of developers on millions of lines of code at Facebook every day. Flow uses sophisticated type inference to ...

Section: Performance

A volatile-by-default JVM for server applications
Lun Liu, Todd Millstein, Madanlal Musuvathi
Article No.: 49
DOI: 10.1145/3133873

A *memory consistency model* (or simply *memory model*) defines the possible values that a shared-memory read may return in a multithreaded programming language. Choosing a memory model involves an inherent performance-programmability tradeoff. ...

Static placement of computation on heterogeneous devices
Gabriel Poesia, Breno Guimarães, Fabrício Ferracioli, Fernando Magno Quintão Pereira
Article No.: 50
DOI: 10.1145/3133874

Heterogeneous architectures characterize today hardware ranging from super-computers to smartphones. However, in spite of this importance, programming such systems is still challenging. In particular, it is challenging to map computations to ...

Skip blocks: reusing execution history to accelerate web scripts
Sarah Chasins, Rastislav Bodik
Article No.: 51
DOI: 10.1145/3133875

With more and more web scripting languages on offer, programmers have access to increasing language support for web scraping tasks. However, in our experiences collaborating with data scientists, we learned that two issues still plague ...

Virtual machine warmup blows hot and cold
Edd Barrett, Carl Friedrich Bolz-Tereick, Rebecca Killick, Sarah Mount, Laurence Tratt
Article No.: 52
DOI: 10.1145/3133876

Virtual Machines (VMs) with Just-In-Time (JIT) compilers are traditionally thought to execute programs in two phases: the initial warmup phase determines which parts of a program would most benefit from dynamic compilation, before JIT compiling ...

Section: Gradual Types and Memory

Model checking copy phases of concurrent copying garbage collection with various memory models
Tomoharu Ugawa, Tatsuya Abe, Toshiyuki Maeda
Article No.: 53
DOI: 10.1145/3133877

Modern concurrent copying garbage collection (GC), in particular, real-time GC, uses fine-grained synchronizations with a mutator, which is the application program that mutates memory, when it moves objects in its copy phase. It resolves a data ...

Sound gradual typing: only mostly dead
Spenser Bauman, Carl Friedrich Bolz-Tereick, Jeremy Siek, Sam Tobin-Hochstadt
Article No.: 54
DOI: 10.1145/3133878

While gradual typing has proven itself attractive to programmers, many systems have avoided sound gradual typing due to the run time overhead of enforcement. In the context of sound gradual typing, both anecdotal and systematic evidence has ...

The VM already knew that: leveraging compile-time knowledge to optimize gradual typing
Gregor Richards, Ellen Arteca, Alexi Turcotte
Article No.: 55
DOI: 10.1145/3133879

Programmers in dynamic languages wishing to constrain and understand the behavior of their programs may turn to gradually-typed languages, which allow types to be specified optionally and check values at the boundary between dynamic and static ...

Sound gradual typing is nominally alive and well
Fabian Muehlboeck, Ross Tate
Article No.: 56
DOI: 10.1145/3133880

Recent research has identified significant performance hurdles that sound gradual typing needs to overcome. These performance hurdles stem from the fact that the run-time checks gradual type systems insert into code can cause significant ...

Section: Tools

Effective interactive resolution of static analysis alarms
Xin Zhang, Radu Grigore, Xujie Si, Mayur Naik
Article No.: 57
DOI: 10.1145/3133881

We propose an interactive approach to resolve static analysis alarms. Our approach synergistically combines a sound but imprecise analysis with precise but unsound heuristics, through user interaction. In each iteration, it solves an optimization ...

Abridging source code
Binhang Yuan, Vijayaraghavan Murali, Christopher Jermaine
Article No.: 58
DOI: 10.1145/3133882

In this paper, we consider the problem of source code abridgment, where the goal is to remove statements from a source code in order to display the source code in a small space, while at the same time leaving the ``important'' parts of ...

Evaluating and improving semistructured merge
Guilherme Cavalcanti, Paulo Borba, Paola Accioly
Article No.: 59
DOI: 10.1145/3133883

While unstructured merge tools rely only on textual analysis to detect and resolve conflicts, semistructured merge tools go further by partially exploiting the syntactic structure and semantics of the involved artifacts. Previous studies ...

Learning to blame: localizing novice type errors with data-driven diagnosis
Eric L. Seidel, Huma Sibghat, Kamalika Chaudhuri, Westley Weimer, Ranjit Jhala
Article No.: 60
DOI: 10.1145/3138818

Localizing type errors is challenging in languages with global type inference, as the type checker must make assumptions about what the programmer intended to do. We introduce Nate, a data-driven approach to error localization based on supervised ...